JAVA第七课-优快云博客

本文链接：https://blog.youkuaiyun.com/aaaghvhg/article/details/148617518

跟日记本一起学JAVA！相信你可以的，加油~

本课闯关内容：1.照猫画虎（0/6）

2.基础知识(0/4...）

———————————————————————————————————————————

基础知识1：

数组

概念：可以通同时存储多个相同类型的数据，并且可以对其中的多个数据统一操作。
使用数组的流程：
（1）声明：指定数组的存储数据类型，同时指定数组名

(建议写法）语法：数据类型[] 数组名; // int[] a;

// int []a; int a[];

（2）分配空间（我起一个数组名是Ann, Ann[5]，我给Ann了5个长度（给了5个位置））：

指定数组的长度数组名 = new 数据类型[长度];
（3）使用数组：【基础重点】

数组中存储的数组被称为数组元素。
对数组的操作分为：存元素和取元素
对数组的存取元素通过数组名和下标进行操作（也叫元素的访问）：

存元素：（在那个位置放东西）
数组名[下标] = 值;
取元素（找那个位置的东西，也就是元素，就是调用时下标输入的数字，代表的是在数组的哪一个位置，就像数学的数列a1,a2...只不过数列的下标开头是1，而数组的下标开头是0。由上面的Ann看，你要调的时候，写的就是Ann[0],Ann[1],Ann[2],Ann[3],Ann[4]，这就是调元素，取元素）：
数组名[下标]

屏幕上要显示：写System.out.println(a[0]);直接取元素

1.对数组的每一个空间进行编号，这个编号被称为下标。

数组的下标范围： 0 ~ 数组长度-1（其实就是把0当作开头，数到数组长度）

2.如果操作数组时，指定的数组下标不在 0~数组长度-1的范围内，编译通过，

运行报错，错误信息为：java.lang.ArrayIndexOutOfBoundsException(数组的下标越界)
（用照猫画虎1举例子，
前提是：
int[] a;
a = new int[6];

（分配了6个空间）
将
a[0]=3;
   a[1]=15;
   a[2]=20;
   a[3]=21;
   a[4]=23;
   a[5]=18;
改为：
a[0]=3;
   a[1]=15;
   a[2]=20;
   a[3]=21;
   a[4]=23;
   a[5]=18;
   a[6]=20;
（多了一个下标6，总共分配了6个空间，但现在超了一个空间）

在你cmd并javac -d . Test1.java，这时不会报错，但是你输入java demo.Test1，才会出现java.lang.ArrayIndexOutOfBoundsException）
3.数组的遍历：对数组中的元素进行一一访问的过程。

语法：
// 用循环的变量控制数组的下标
for(int i=0;i< 数组的长度；i++){

// 通过 a[i] 操作数组的每一个元素

}

获取数组的长度：数组名.length（可以动态获取）
(还拿Ann举例子)（i是一个数）i<Ann.length

4.数组具有默认值值，默认值情况如下：
整数： 0
小数：0.0
布尔：false
字符：空字符 (\u0000)
对象/引用：null

(以照猫画虎1为例

前提是：
int[] a;
a = new int[6];

（分配了6个空间）
将
a[0]=3;
a[1]=15;
a[2]=20;
a[3]=21;
a[4]=23;
a[5]=18;

改为：

a[0]=3;
a[1]=15;
a[2]=20;
a[3]=21;
a[4]=23;

(少了一个下标为5的，输入java demo.Test1此时输出下标0对应的数据为：3
下标1对应的数据为：15
下标2对应的数据为：20
下标3对应的数据为：21
下标4对应的数据为：23
下标5对应的数据为：0
数组的长度6
20
0
平均值13.666666666666666
15
21
0
)下标5对应的数据为：0（int（整数）的默认值为0）

）

照猫画虎1：

package demo;

public class Test1{
	public static void main(String[]args){
	//存储 65名同学的年龄
	int age =18;  
	int age2 =20; 
	int age3 =18; 
    //..定义65个int类型的变量

    //定义一个  数组，存储5个学生年龄
    //1.声明
    int[] a;//声明：确定数组的数据类型和数组名
    //2.分配空间
    a = new int[6];//分配空间：确定数组的长度
    //3.使用
 	a[0]=3;
	a[1]=15;	
	a[2]=20;	
	a[3]=21;	
	a[4]=23;
	a[5]=18;
	//System.out.println(a[0]);
	//System.out.println(a[1]);
	//System.out.println(a[2]);
	//System.out.println(a[3]);
	//System.out.println(a[4]);
	//前提是没有a[5]数组，System.out.println(a[5]);java.lang.ArrayIndexOutOfBoundsException数组下标越界（访问数组时，超过数组下标的范围）
	//利用循环变量控制数组的下标
	//数组的历遍：将数组中的数据一一访问
	for(int i=0;i<a.length;i++){
	    System.out.println("下标"+i+"对应的数据为："+a[i]);	
	}
	System.out.println("数组的长度"+a.length);
	//打印输出 数组中的偶数
	for(int i=0;i<a.length;i++){
	    if(a[i]%2==0){
		System.out.println(a[i]);
	  }
	}
	//计算数组中所有数据的平均数，并打印输出
	int sum =0;
	for(int i=0;i<a.length;i++){
    sum +=a[i];
	}
	System.out.println("平均值"+(double)sum/a.length);
	
	
	
	//打印奇数下标得内容对应的元素(下标：1.3.5-->)	
	for(int i=0;i<a.length;i++){

	  if(i%2!=0){
		System.out.println(a[i]);
	  }
	}
	//打印奇数下标，改变i
	
	}
	    
}

1.咱们的年龄是一年长一岁，所以用循环结构进行数组的遍历。
2.//打印输出数组中的偶数
   for(int i=0;i<a.length;i++){
   if(a[i]%2==0){
       System.out.println(a[i]);
   }
   }
   //计算数组中所有数据的平均数，并打印输出

//打印奇数下标得内容对应的元素(下标：1.3.5-->)
for(int i=0;i<a.length;i++){

   if(i%2!=0){
       System.out.println(a[i]);
   }
   }

一个是打印数组中的偶数为数组中的元素的偶数，另一个是打印奇数下标。

输出：
下标0对应的数据为：3
下标1对应的数据为：15
下标2对应的数据为：20
下标3对应的数据为：21
下标4对应的数据为：23
下标5对应的数据为：18
数组的长度6
20
18
平均值16.666666666666668
15
21
18

基础知识2：

1.数组的其他定义方式（重点）：
（1）声明的同时分配空间：数据类型[] 数组名 = new 数据类型[长度];
（2）声明的同时显示初始化：数据类型[] 数组名 = new 数据类型[]{值1,值2,值3};              注意：[]中不能再指定数组的长度，长度有{}中值个数决定。
（3）显示初始化：数据类型[] 数组名 = {值1, 值2, 值3};             注意：声明和初始化必须一起完成，同时数组的长度由{}中值个数决定。
eg: int[] a ;                         a = {1,7,4}; //error错误（错误的）（这是先声明再初始化这是错误的，必须同时）

int[] a ={3,7,9,12,4};(正确的)

2.数组的内存
（1）数组在内存中空间是连续的（你给分配空间（写数字，给长度）也是连续的在电脑内存中）。

（2）数组名存储的是 数组在内存中的首地址。

（3）计算机中的寻址方式：首地址 + 下标 * 每一个存储空间的字节数。--->(数组名[下标])

（4）数组下标从 0开始，是为了提高寻址效率。

（5）数组类型的变量相互赋值，传递的是数组在内存中首地址。

基本数据类型变量相互赋值，传递的是数值（在数组中传递的是数组中的元素，假如说a数组有3个元素，b数组有4个元素，把b赋给a，传递的是元素，你第一时间是不是认为b的长度大于a的长度，怎么赋值呢，不，直接赋值，之后a数组与b数组中的元素一摸一样了）。

同类型的数组类型，是可以直接相互赋值的

在这种数组的代码，一但出错有可能显示出一大堆错，先看第一行先改第一行，说不定下面的错误就都没了

照猫画虎2：

package demo;

public class Test2{
	public static void main(String[]args){
	//第二种定义方式：声明的同时并分配空间	
	double [] ds = new double[4];
    ds[0] = 9.8;	
	ds[1] = 9.0;		
	ds[2] = 7.8;			
	ds[3] = 17.8;	
	for(int i =0;i<ds.length;i++){
		System.out.println(ds[i]);
	}
	
	//第三种定义方式：声明的同时并初始化（显示的初始化）
	String[] strs = new String[]{"aa","bb","cc"};
    for(int i=0;i<strs.length;i++){
		System.out.println(strs[i]);
	}	

	//第四种定义方式：显示初始化
	int[] a ={3,7,9,12,4};
	for(int i=0;i<a.length;i++){
		System.out.println(a[i]);
	}	
	
	int[] bs =new int[3];
	for(int i=0;i<bs.length;i++){
		System.out.println(bs[i]);
	}	
	
	
	
	}
}

int[] bs =new int[3];
   for(int i=0;i<bs.length;i++){
       System.out.println(bs[i]);
   }
仅声明不初始化就用到下面的知识了。

输出：

9.8
9.0
7.8
17.8
aa
bb
cc
3
7
9
12
4
0
0
0

基础知识3：

数组的扩容

扩容思想：
（1）先申请一个更大空间的新数组，通常新数组长度为原数组长度的2倍
（2）将原数组中的元素进行一一复制到新数组中
（3）新地址覆盖旧地址
数组扩容实现的方式：
（1）第一种方式：

int[] a = new int[]{1,7,4,3};

// 1. 申请新数组：长度为原有数组的2倍

int[] b = new int[a.length*2];

// 2. 将原有数组中内容进行一一拷贝到新数组中

for(int i=0;i<a.length;i++){ b[i] = a[i]; }

// 3. 新的地址覆盖旧的地址 a = b;

（2）第二种方式：利用 System.arraycopy(a,0,b,0,a.length); // 完成数组复制

（是你填System.arraycopy(a,0,b,0,a.length);括号里的）参数说明：
第一个参数：原数组名
第二个参数：原数组拷贝的起始下标
第三个参数：新数组名第四个参数：新数组的存储起始下标第五个参数：拷贝的个数/长度

（3）第三种方式：利用 java.util.Arrays.copyOf(原数组名,新数组的长度) ； // 完成新数组的定义+数组的复制

（还是填java.util.Arrays.copyOf(原数组名,新数组的长度) ；括号里的，）参数说明：第一个参数：扩容的数组名（就是你想扩容的数组名，也就是原数组名）
第二个参数：指定新数组的长度

照猫画虎3：

package demo;

public class Test1{
	public static void main(String[]args){
		int[]a={1,8,4,6};
		//扩容：
		//1.定义一个更大长度的新数组
		int []b=new int[a.length*2];
		//2.将原来数组中的数据赋值到新的数组中
		for(int i=0;i<a.length;i++){
			b[i]=a[i];
			
		}
		//3.新的地址覆盖旧的地址
		a=b;
		for(int i=0;i<a.length;i++){
			System.out.println(a[i]);
			
		}
		
		//第二种扩容方式：借助工具类
		a=java.util.Arrays.copyOf(a,a.length*2);
		System.out.println("第二次扩容之后的数据:");
		for(int i=0;i<a.length;i++){
			System.out.println(a[i]);
			
		}
		
	}
}

输出：

1
8
4
6
0
0
0
0
第二次扩容之后的数据（int []b=new int[a.length*2];，这不就是乘以2倍了嘛，原来是8个长度，现在是16个长度，但是我们只给前4个元素了，所以不管是扩容前还是扩容后，之后的位置都输出的默认值）:
1
8
4
6
0
0
0
0
0
0
0
0
0
0
0
0

基础知识4：

数组的排序

1.冒泡排序法：将相邻的两个元素进行一一比较，元素大逐步往后移。 (从小到大排序) （照猫画虎4就是用的这个方法）

2.选择排序：固定一个下标对应的元素，和其他元素进行一一比较，较小数据逐步往前移。(从小到大排序)

3.利用 java.util.Arrays.sort(数组名); 进行排序 --->快速排序

照猫画虎4：

package demo;

public class Test2{
	public static void main(String[]args){
		
		
		
		int[]a={9,4,5,2};
		//将数组中数据进行从小到大排序
		/*冒泡排序：相邻的两个元素进行一一比较
		/*
		
		两个比较项：j控制比较第一个下标，j+i第二个比较项
		每次都是a[j]和a[j+1]进行比较
		
		*/
		//外层循环：控制重复轮数
		
		
		for(int i=0;i<a.length;i++){
			for(int j=0;j<a.length-i;j++){
				
			//判断a[j]和a[j+1]的大小
				if(a[j]>a[j+1]){
					//需要两个变量之间进行交换
					int temp =a[j];//借助第三个变量实现两个变量交换
					a[j]=a[j+1];
					a[j+1]=temp;
				}
			}
		}
		//第一轮：i=1
		/*for(int j=0;j<3;j++)*/
		java.util.Arrays.sort(a);
		for(int i=0;i<a.length;i++){
			System.out.println(a[i]);
		}
		
	}
}

输出：

2
4
5
9

基础知识5：

二维数组

语法：
（1）声明：数据类型 [] [] 数组名;
（2）分配空间：数组名 = new 数据类型[行数] [列数]; // 行又称为高维列：低维
二维数组的使用：
（1）通过行和列对二位数组进行访问（语法）（前面的[]为行标，后面的[]为列标，前后不能变）：数组名[行标] [列标]
注意：行标和列表都是从 0 开始

例如： a[0] [3] // 第0行第3列的元素

（2）二维数组也具有默认值，同一维数组
（3）获取二维数组的行数：数组名.length

列数：数组名[行标].length 注意：二维数组是一维数组的一维数组。

3.二维数组的其他定义方式
(1)声明的同时并分配空间：数据类型[][] [] [] 数组名 = new 数据类型[行数] [列数];
(2) 显示初始化：数据类型[] [] 数组名 = new 数据类型[] []{{值1,值2},{值3,值4},{值5,值6}}; 注意：后面 {} 中 {}的个数决定行数，所以[] []中个不能再制定行数和列数。
(3) 显示初始化：数据类型[] [] 数组名 = {{值1,值2},{值3,值4}}; 注意：声明和初始化必须一起完成。

4.不规则的二维数组
(1)概念：每一行的列数不相同
(2) 不规则的二维数组的定义方式：
a.(行数确定了，列数一个个定义)
数据类型[] [] 数组名 = new 数据类型[行数] []；

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

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

....

注意：二维数组定义可以只指定行数/高维，但是不能只指定列数/低维

b.数据类型[] [] 数组名 = {{值1},{值1,值2,值3},{值1,值2}};