1.重载&访问修饰符&静态&常用类的回顾

2.本章重点

2.1数组的定义和使用

2.2.数组排序

2.3二维数组

2.4对象数组

2.5Arrays工具类的使用

3.具体内容

3.1数组的定义和使用

3.1.1什么是数组

所谓数组，是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。

在js中，数组没有数据类型限制,并且可以随意扩容。Java中的数组就是将相同数据类型的数据 进行存储的数据格式。并且存储到数组中的数据都会自动生成一个编号，称之为索引值或者下标。然后数组是通过操作索引值对数据进行存取。索引值从0开始。并且java中的数组是定容，统一数据类型的。

3.1.2.java数组的特点

java数组是一种引用数据类型

java数组中的数据类型必须统一

java数组是定长的（长度一旦确定就不能变化）

数组的重新赋值，只能通过标准格式，不能使用简化格式赋值

初始化数组时如果没有直接赋值，那么数组中元素的默认值整数: 0 浮点数: 0.0 字符:'\u0000' 布尔型:false 引用类型:null

因为数组是定长的，如果想扩容只能创建一个新的数组。Arrays.copyOf(原始数组，长度)

3.1.3数组的定义

语法:

// 定义有容量的数组

数据类型[] 数组变量 = new 数据类型[数组容量];

// 定义有初始化数据的数组.后面的中括号中不能写长度

数据类型[] 数组变量 = new 数据类型[]{数据1,数据2...};

// 直接赋值创建(静态创建)，定义和赋值必须写在一起

数据类型[] 数组变量 = {数据1,数据2...};

实例:

public static void main(String[] args) {

/*

数据类型 变量名 = 数据;

数据类型[] 数组变量名 = new 数据类型[长度];

*/

//int num = 10; // 普通变量

//int[] numAry = new int[10]; // 数组对象

// java中的数组创建

// 方式一: 定义数组变量，并创建特定长度的数组空间

// 没有赋值，有默认值: int 0,String null,char '0',boolean false

int[] numAry = new int[5];

//System.out.println(numAry); // 输出数组再内存地址

/*System.out.println(numAry[0]);

System.out.println(numAry[1]);

System.out.println(numAry[2]);

System.out.println(numAry[3]);

String[] nameAry = new String[3];

//System.out.println(nameAry);

System.out.println(nameAry[0]);

System.out.println(nameAry[1]);

System.out.println(nameAry[2]);

//System.out.println(nameAry[3]);*/

//Array(数组)Index(索引)OutOf(超出)Bounds(边界)Exception(异常)

// 方式二: 定义数组变量，并使用new的方式进行数据初始化

// 后面的中括号，一定不能写长度

int[] numAry2 = new int[]{200,100,300}; // 根据个数创建数组空间，并赋值

/*System.out.println(numAry2.length); // length:数组长度

System.out.println(numAry2[0]);

System.out.println(numAry2[1]);

System.out.println(numAry2[2]);*/

// 方式三: 定义变量，用静态方式直接进行初始化

// 这种方式必须再声明变量的同时进行赋值。不能先声明变量，再赋值

int[] numAry3 ={12,34,11,39};

// 循环

for (int i=0;i<numAry3.length;i++){

System.out.println(numAry3[i]);

}

}

3.1.4数组的使用

语法:

// 创建数组

数据类型[] 数组变量 = new 数据类型[数组容量];

// 通过数组变量+下标为数组元素赋值。数组的最大下标只能取到"数组容量-1"

数组变量[下标1] = 数据1;

数组变量[下标2] = 数据2;

...

数组变量[数组容量-1] = 数据n;

// 通过数组变量+下标访问数组元素

System.out.println(数组变量[下标])

实例:

public class Test2 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

// 定义长度为5的整形数组,输入5个分数,并遍历输出

int[] scoreAry = new int[5];

//scoreAry[0] =234;

//scoreAry[1] = 456;

for (int i=0;i<scoreAry.length;i++){

System.out.println("请输入第"+(i+1)+"个学生的分数:");

int s = sc.nextInt(); // 接收整数

// 将分数存入数组中

scoreAry[i] = s;

}

System.out.println("==================");

// for+索引 遍历

for (int i=0;i<scoreAry.length;i++){

System.out.println(scoreAry[i]);

}

System.out.println("==================");

// for each 遍历

for(int t : scoreAry){

System.out.println(t);

}

}

}

注意: 当数组下标超出数组边界的时候，会报出ArrayIndexOutOfBoundsException

3.1.5数组在内存中的存储方式

int[] scoreAry = new int[5];
// for each 遍历
for(int t : scoreAry)
{    
System.out.println(t);
}

3.1.6数组的遍历

方式一:for+索引

int[] scoreAry = new int[5];
// for+索引 遍历
for (int i=0;i<scoreAry.length;i++){    
System.out.println(scoreAry[i]);
}

方式二:for each 遍历

int[] scoreAry = new int[5];
// for each 遍历
for(int t : scoreAry){
    System.out.println(t);
}

3.1.7数组的操作

求数组最大值，最小值，最大值下标，最小值下标

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

// 定义长度为5的整形数组,输入5个分数,并遍历输出

int[] scoreAry = new int[5];

//scoreAry[0] =234;

//scoreAry[1] = 456;

for (int i=0;i<scoreAry.length;i++){

System.out.println("请输入第"+(i+1)+"个学生的分数:");

int s = sc.nextInt(); // 接收整数

// 将分数存入数组中

scoreAry[i] = s;

}

System.out.println("==================");

// for+索引 遍历

for (int i=0;i<scoreAry.length;i++){

System.out.println(scoreAry[i]);

}

System.out.println("==================");

// for in 遍历

for(int t : scoreAry){

System.out.println(t);

}

}

// 定义数组，存储5个分数，求最高分，最低分，最高分位置，最低分位置

public static void main(String[] args) {

// 定义数组，存储5个分数，求最高分，最低分，最高分位置，最低分位置

int[] scores = {67,34,88,29,5,87,120,33,58,90};

// 定义最大值位置

int maxPos = 0;

// 定义最小值位置

int minPos = 0;

for (int i = 1; i < scores.length; i++) {

// 比较对应位置上的数据

if(scores[i]>scores[maxPos]){

// 记录数据的位置

maxPos = i;

}

if(scores[i]<scores[minPos]){

minPos = i;

}

}

System.out.println("最大值:"+scores[maxPos]+" 最大值位置:"+maxPos );

System.out.println("最小值:"+scores[minPos]+" 最小值位置:"+minPos );

}

3.1.8排序算法

。冒泡排序

public static void main(String[] args) {

// N元数组冒泡序，两两相比小前移，外层循环从1始，内层循环减i去

// 冒泡排序:

// 1.比较 2.换位

int[] numAry = {20,12,33,8,4,1,200,34,98};

// 外层控制轮数

for(int i=1;i<numAry.length;i++){

// 内层控制比较过程(次数)

for(int j=0;j<numAry.length-i;j++) {

//核心

// 比较

if (numAry[j] > numAry[j + 1]) {

// 换位

int temp = numAry[j];

numAry[j] = numAry[j + 1];

numAry[j + 1] = temp;

}

}

}


for(int n :numAry){

System.out.println(n);

}

}

。选择排序

选择: 每轮排序都选择数据最小的那个元素（下标），与本轮排位第一的元素换位

public static void main(String[] args) {

int[] numAry = {1,12,33,8,4,200,34,20,98};

//k=1 k=5

// 控制轮数,记录本轮第一个元素的位置

for (int i=0;i<numAry.length-1;i++){

int k=i; // 记录最小值的位置

for(int j=i+1;j<numAry.length;j++){

// 通过比较，记录最小值的位置

// 如果k上的值，比j上的值大

if(numAry[k]>numAry[j]){

// 就要把j的值赋值给k。k总是指向最小值

k = j;

}

}

// 找到本轮最小值的位置

System.out.println("K:"+k);

// 如果最小值的位置，和排位第一的位置不同，则换位

if(k!=i){

int temp = numAry[i];

numAry[i] = numAry[k];

numAry[k] = temp;

}

}


// 循环输出

for (int n :numAry){

System.out.println(n);

}

}

3.1.9Arrays数组工具类

// 定义数组

int[] nums = {20,30,40,12,17};

// 排序

Arrays.sort(nums);

for (int n : nums){

System.out.println(n);

}

// 字符串

String res = Arrays.toString(nums);

System.out.println(res);

// 扩展数组（重点内容，是后面ArrayList集合扩容的核心方法）

int[] my = Arrays.copyOf(nums,20);

System.out.println(Arrays.toString(my));

3.2对象数组

3.2.1对象数组创建和遍历

public static void main(String[] args) {

// 定义对象数组

//int[] nums; // 整形数组

//String[] strs; // 字符串数组

//Student[] stus; // 学生数组,每个元素空间，必须存储学生对象

Student[] stus = new Student[10];

// 在数组第一个位置存储一个学生

Student s1 = new Student("张三","男",20);

//System.out.println(s1.name+" "+s1.sex);

//System.out.println(s1);

stus[0] = s1;

stus[1] = new Student("李四","女",18);

stus[2] = new Student("王五","女",18);

stus[3] = new Student("赵六","女",18);

stus[4] = new Student("孙琪","女",18);

// 遍历学生对象

for (int i=0;i<stus.length;i++){

if(stus[i]!=null) {

Student x = stus[i];

System.out.println(x.name+" "+x.sex+" "+x.age);

//System.out.println(stus[i].name + " " + stus[i].sex + " " + stus[i].age);

}

}

}

3.2.2对象数组的排序

public class Test2 {

public static void main(String[] args) {

Student[] stus = new Student[3];

stus[0]=new Student("张三","男",20);

stus[1]=new Student("李四","男",19);

stus[2]=new Student("王五","男",25);

for (Student s: stus){

s.show();

}

System.out.println("====================");

// 冒泡排序

for(int i=1;i<stus.length;i++){

for(int j=0;j<stus.length-i;j++){

// 前面的学生和后面学生的年龄相比

if(stus[j].age>stus[j+1].age){

// 年龄大的学生，向后移动

Student temp = stus[j];

stus[j]=stus[j+1];

stus[j+1]=temp;

}

}

}

for (Student s: stus){

s.show();

}

}

}

3.3二维数组

public static void main(String[] args) {

// 存储一排学生的位置

String[] names1 = {"张三","李四","王五"};

// 存储一个班级的学生

String[][] names2= new String[][] {

//0 1 2

{"张三","李四","王五"}, // 0

{"赵六","孙琪","王高"}, // 1

{"高达","悟空","唐僧"} // 2

};

// 创建二维数组: [行][列]

String[][] names3 = new String[3][5];

for (int i = 0; i < names2.length; i++) {

System.out.println("第"+(i+1)+"排:");

for (int j=0;j<names2[i].length;j++){

System.out.print(names2[i][j]+" ");

}

System.out.println();

}

/*System.out.println(names2[0][0]);

System.out.println(names2[0][1]);

System.out.println(names2[0][2]);

System.out.println(names2[1][0]);

System.out.println(names2[1][1]);*/

}

4.本章总结

数组的定义和使用
数组排序
Arrays工具类的使用
二维数组
对象数组

感谢观看，本章到此结束。

java的学习--第五章数组及排序

1.重载&访问修饰符&静态&常用类的回顾

2.本章重点

2.1数组的定义和使用

2.2.数组排序

2.3二维数组

2.4对象数组

2.5Arrays工具类的使用

3.具体内容

3.1数组的定义和使用

3.1.1什么是数组

3.1.2.java数组的特点

3.1.3数组的定义

3.1.4数组的使用

3.1.5数组在内存中的存储方式

3.1.6数组的遍历

3.1.7数组的操作

3.1.8排序算法

3.1.9Arrays数组工具类

3.2对象数组

3.2.1对象数组创建和遍历

3.2.2对象数组的排序

3.3二维数组

4.本章总结

猜你喜欢

java的学习--第五章 数组及排序

1.重载&访问修饰符&静态&常用类的回顾

2.本章重点

2.1数组的定义和使用

2.2.数组排序

2.3二维数组

2.4对象数组

2.5Arrays工具类的使用

3.具体内容

3.1数组的定义和使用

3.1.1什么是数组

3.1.2.java数组的特点

3.1.3数组的定义

3.1.4数组的使用

3.1.5数组在内存中的存储方式

3.1.6数组的遍历

3.1.7数组的操作

3.1.8排序算法

3.1.9Arrays数组工具类

3.2对象数组

3.2.1对象数组创建和遍历

3.2.2对象数组的排序

3.3二维数组

4.本章总结

猜你喜欢

java的学习--第五章数组及排序