java复习

第二部分：Java数组

#1. Java 数组的定义
##Java中数组的定义有两种：
type arrayName[]
type[] arrayName;

#2. Java 数组的声明
###如：int[] i或int[] i=new int[5];

#3. 数组的优势与局限
优点：1.按照索引查询元素速度快
2.能存储大量的数据
3.按照索引遍历数组方便
缺点：
1.根据内容查找元素速度慢
2.数组只能存储一种类型的数据
3.数组的大小一经确定不能改变
4.增加，删除元素效率慢
5.未封装任何方法，所有操作都需要用户定义

#4. 数组的动态初始化
5. 方法一：

{

//动态初始化

int[] arr1 = new int[5]; //声明、创建

arr1[0] = 0;//初始化

arr1[0] = 1;

arr1[0] = 2;

arr1[0] = 3;

arr1[0] = 4;

}

方法二：

{

//静态初始化

int[] arr2 = new int[] {1,2,3,4,5};//声明、创建、初始化

}

方法二(1)：

{

//静态初始化的分开写法

int[] arr2 ;//声明数组标识符

arr2 = new int[] {1,2,3,4,5};//创建数组对象，并初始化

}

方法二(错误写法！切忌)：

{

//静态初始化的分开写法

int[] arr2 ;//声明数组标识符

arr2 = new int[5] {1,2,3,4,5};//java语法不允许这样做（想想看这样做确实没有必要，你既然已经静态赋值初始化了，还要标记数组的长度，没有意义）

}

方法三：

{

//静态初始化的简单写法

int[] arr2 = {1,2,3,4,5};

}

注意：：：这种写法不能像上面那样分开写
方法三（错误写法！切忌）：

{

//简单的写法有弊端，即不能分开写

int[] arr2 ；//XXXXXXXXXXXXXX

arr2 = {1,2,3,4,5};//XXXXXXXXXXXXXXXX

}

#5. 数组的存储特点（堆和栈）
栈内存中数据用完就会释放掉。是脱离了变量的作用域后会释放掉。

那么下面举一个我写的小例子：
【需求】：
* 定义第一个数组，定义完毕后，给数组元素赋值，赋值完毕后，在输出数组名称和元素。
* 定义第二个数组，定义完毕后，给数组元素赋值，赋值完毕后，在输出数组名称和元素。
* 定义第三个数组，把第一个数组的地址赋值给它。（注意类型一致），通过第三个数组的名称去把元素重 复赋值。
* 最后，再次输出第一个数组数组名称和元素。
public static void main(String[] args) {
//定义第一个数组
int[] arr=new int[3];
arr[0]=10;
arr[1]=20;
arr[2]=70;
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println("--------------");

	//定义第二个数组
	short[] arr2=new short[2];
	arr2[0]=30;
	arr2[1]=40;
	System.out.println(arr2);
	System.out.println(arr2[0]);
	System.out.println(arr2[1]);
	System.out.println("--------------");
	
	//定义第三个数组
	int[] arr3=arr;
	arr3[0]=100;
	arr3[1]=200;
	arr3[2]=300;
	System.out.println(arr);
	System.out.println(arr[0]);
	System.out.println(arr[1]);
	System.out.println(arr[2]);

}

【运行结果：】

这里详细解释一下运行步骤：
数组一：
第一步：栈存储局部变量（在方法定义中或方法声明上的变量），所以int[] arr 存放在了栈中；
第二步：new出的变量放在堆中，所以new int【3】在堆中。
第三步：每一个new出来的东西都有地址值（系统随机分配），所以new int【3】的地址值为0x001;
把0x001赋给arr，在栈中的数组通过地址值找到堆中相应的地址。用数组名和编号的配合就可以找 到数组中指定编号的元素，这种方法就叫做索引。
第四步：int类型的数据默认值为0
第五步：给数组中的每个元素赋值，把原先的默认值干掉。
第六步：逐个输出相应的值。
数组二和数组一相同。
数组三:
开辟一个内存空间 int[] arr3，把arr3的地址值0x001赋给该数组，所以数组3此时指向堆内存中的0x001对象。
100赋值给编号为0的元素，200赋值给编号为1的元素。
依次输出。

画一张图来更形象的表示：

#6. 数组的遍历访问（普通循环，增强for循环）
public class HelloWorld {
public static void main(String[] args) {
int[] arr=new int[]{1,2,3,4,8,6,4,7,9};
//for循环
for (int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
System.out.println();
for (int i: arr) {
System.out.print(i+"\t");
}

}
}

#7. 数组元素的顺序查找
public class HelloWorld {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int[] arr=new int[]{1,2,3,4,8,6,10,7,9};
System.out.println(“请输入要查找的数：”);
int de=((Scanner) sc).nextInt();
for(int i=0;i<arr.length;i++){
if(arr[i]==de){
System.out.println(“找到的数位置为：”+(i+1));
}
}
}
}

#8. 数组元素的二分法查找
public class HelloWorld {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int[] arr=new int[]{1,2,3,4,5,6,7,8,9};
System.out.println(“请输入要查找的数：”);
int de=((Scanner) sc).nextInt();
int low=0;
int high=arr.length-1;
int middle=0;
if(de<arr[0]||de>arr[high]||low>high){
System.exit(0);
}
while(low<=high){
middle=(low+high)/2;
if(arr[middle]>de){
high=middle-1;
}else if(arr[middle]<de){
low=middle+1;
}else {
System.out.println(“查找的元素所在的位置：”+(middle+1));
break;
}
}
}
}

#9. 数组元素的选择排序
public class HelloWorld {
public static void main(String[] args) {
//数组的选择排序
int[] arr=new int[]{1,8,6,5,47,9,3,7};
for(int i=0;i<arr.length;i++){
for(int j=i;j<arr.length;j++){
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
for (int i:arr
) {
System.out.print(i+"\t");
}
}
}

#10. 数组元素的冒泡法排序
public class HelloWorld {
public static void main(String[] args) {
//数组的选择排序
int[] arr=new int[]{1,8,6,5,47,9,3,7};
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr.length;j++){
if(arr[i]<arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
for (int i:arr
) {
System.out.print(i+"\t");
}
}
}

#11. Arrays工具类的使用
public class HelloWorld {
public static void main(String[] args) {
//Array类的使用
int[] arr=new int[]{15,48,56,15,88,1,54,65};
// 返回一个受指定数组支持的固定大小的列表。
List stooges = Arrays.asList(“Larry”, “Moe”, “Curly”);
for (String s: stooges
) {
System.out.print(s+"\t");
}
//使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。
int i1=Arrays.binarySearch(arr,2);
//使用二分搜索法来搜索指定的 byte 型数组的范围，以获得指定的值。
int i2=Arrays.binarySearch(arr,1,3,2);
System.out.print(i1+"\t"+i2);
//复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
int[] b1=Arrays.copyOf(arr,5);
for (int b:b1
) {
System.out.print(b+"\t");
}
int[] i3=Arrays.copyOfRange(arr,1,3);
for (int b:i3
) {
System.out.print(b+"\t");
}
//基于指定数组的“深层内容”返回哈希码
int i4=Arrays.deepHashCode(new String[] {“1”,“2”});
System.out.println(i4);
//如果两个指定的 byte 型数组彼此相等，则返回 true。
boolean b2=Arrays.equals(arr,b1);
System.out.println(b2);
//基于指定数组的内容返回哈希码
int i5=Arrays.hashCode(arr);
System.out.println(i5);
// 对指定的 int 型数组按数字升序进行排序。
Arrays.sort(arr);
for (int b:arr
) {
System.out.print(b+"\t");
}

}
}

#12. 二维数组的介绍
可以理解为数组中的数组

#13. 二维数组的声明与初始化
两种初始化形式
1.动态初始化

数据类型 数组名[][]=new 数据类型[m][n]
数据类型[] 数组名[]=new 数据类型[m][n]

2.静态初始化
数据类型[][] 数组名={{元素1，元素2……},{元素1，元素2……}};

#14. 二维数组的遍历
public class HelloWorld {
public static void main(String[] args) {
int[][] arr=new int [][]{{2,1},{5,6},{7,8}};
int length=arr.length;
System.out.println(length);
for (int i=0;i<arr.length;i++){
for (int j=0;j<arr[i].length;j++){
System.out.print(arr[i][j]+"\t");
}
}
System.out.println();
for (int[] i:arr
) {
for (int i1: i
) {
System.out.print(i1+"\t");
}
}
}
}