一、数组

1.一维数组

概念：一组数据的容器（数组可以存放多个数据）
注意：
1.数组是引用数据类型
2.数组中的数据又叫做元素
3.每个元素都有编号叫做下标/索引
4.下标从0开始
5.数组初始化后，会在内存中开辟一连串连续的空间
6.数组一旦初始化后长度不可以改变（数组没有扩容和删除）
7.数组的操作：添加、修改、查询
数组的声明：数据类型[] 数组名;
数组的初始化：
静态初始化：数据由程序员指定，长度由系统分配
动态初始化：长度由程序员指定，数据由系统分配(默认值)

​ 整数类型：0
​ 浮点类型：0.0
​ 字符类型：’ ’
​ 布尔类型：false
​ 引用类型：null(空)

遍历 - for循环
遍历 - foreach(增强for循环)
遍历时要使用到下标，就用for循环遍历
遍历时要不使用到下标，就用foreach遍历

静态初始化：数据由程序员指定，长度由系统分配

public class Test09{
	
	public static void main(String[] args){
		
		//静态初始化1
		//String[] names = new String[]{"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};
		
		//静态初始化2
		//String[] names;
		//names = new String[]{"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};
		
		//静态初始化3
		String[] names = {"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};
        
		//设置指定下标上的元素
		names[3] = "aa";
		//获取指定下标上的元素
		String n = names[3];
		System.out.println("获取指定下标上的元素：" + n);//
		//ArrayIndexOutOfBoundsException - 数组下标越界异常
		//System.out.println(names[100]);
		//获取元素个数
		int len = names.length;
		System.out.println("获取元素个数：" + len);//5
		System.out.println("-----------");
		//遍历 - for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		System.out.println("-----------");
		//遍历 - foreach(增强for循环)
		for(String str:names){//遍历数组，依次把元素赋值给str
			System.out.println(str);
		}
		for(String s:names){
			System.out.println(s);
		}
	}
}

动态初始化：长度由程序员指定，数据由系统分配(默认值)

public class Test10{

	public static void main(String[] args){
		
		//动态初始化1
		String[] names = new String[5];//5->5个长度
		//设置指定下标上的元素
		names[0] = "aa";
		names[1] = "bb";
		names[2] = "cc";
		names[3] = "dd";
		names[4] = "ee";
		//获取指定下标上的元素
		String n = names[3];
		System.out.println("获取指定下标上的元素：" + n);//
		//ArrayIndexOutOfBoundsException - 数组下标越界异常
		//System.out.println(names[100]);
		//获取元素个数
		int len = names.length;
		System.out.println("获取元素个数：" + len);//5
		
		System.out.println("-----------");
		
		//遍历 - for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		System.out.println("-----------");
		//遍历 - foreach(增强for循环)
		for(String str:names){//遍历数组，依次把元素赋值给str
			System.out.println(str);
		}
	}
}

1.1 静态初始化和动态初始化

静态初始化 vs 动态初始化
一开始就知道数据：静态初始化
一开始就知道长度：动态初始化

1.2 数组的排序—冒泡排序

口诀：
N个数字来排序
两两相比小靠前
外层循环N-1
内层循环N-1-i

public class Test01{
	
	public static void main(String[] args){
		
		int[] is = {39,77,27,20,45,62};
		
		for(int i = 0;i<is.length-1;i++){
			for(int j = 0;j<is.length-1-i;j++){
				if(is[j] > is[j+1]){
					int temp = is[j];
					is[j] = is[j+1];
					is[j+1] = temp;
				}
			}
		}
		for(int num : is){
			System.out.println(num);
		}
	}
}

1.3 数组的查找

1.3.1 顺序查找

顺序查找：从头到尾遍历

public class Test02{

	public static void main(String[] args){
		int[] is = {39,77,27,20,45,62};
        int num = 77;
        for(int i = 0;i<is.length;i++){
            if(is[i] == num){
                System.out.println("查找到了");
            }
        }	
	}
}

1.3.2 二分查找

前提：先排序

import java.util.Arrays;
public class Test02{

	public static void main(String[] args){
		
		int[] is = {39,77,27,20,45,62};
		int num = 77;
		//排序
		Arrays.sort(is);
		int start = 0;
		int end = is.length-1;
		while(start <= end){
			int mid = (start+end)/2;
			if(num >is[mid]){
				start = mid+1;
			}else if(num < is[mid]){
				end = mid-1;
			}else{
				System.out.println("查找到了");
				break;
			}
		}
	}
}

1.4 数组的复制

第一种方法：new一个新数组，直接将原数组的地址赋值给新数组

缺点：修改原数组，新数组的数据也随之改变

public class Test03{
	
	public static void main(String[] args){
		
		//原数组
		String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
		
		//新数组
		String[] newNames = names;
		
		//修改原数组
		names[0] = "三上悠亚";
		
		//遍历新数组
		for(String name : newNames){
			System.out.println(name);
		}
	}
}

第二种方法：new一个新数组，将原数组中的数据复制给新数组，此时修改原数组，新数组中的数据不会改变

public class Test04{
	
	public static void main(String[] args){
		
		//源数组
		String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
		
		//新数组
		String[] newNames = new String[names.length];
		
		//将原数组中数据依次赋值给新数组
		for(int i = 0;i<names.length;i++){
			newNames[i] = names[i];
		}
	
		//修改原数组
		names[0] = "三上悠亚";
		
		//遍历新数组
		for(String name : newNames){
			System.out.println(name);
		}
	}
}

1.5 数组的扩容

public class Test05{

	public static void main(String[] args){
		
		//原数组
		String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
		
		//新数组
		int capacity = names.length + (names.length>>1);//新容量：是原数组长度的1.5倍
		String[] newNames = new String[capacity];
		
		//把原数组所有的数据迁移到新数组中
		for(int i = 0;i<names.length;i++){
			newNames[i] = names[i];
		}
		
		//将新数组的地址赋值给原数组
		names = newNames;
		
		//遍历原数组
		for(String name:names){
			System.out.println(name);
		}
	}
}

1.6 数组的删除

第一种方法：创建新数组将除了要删除的数据其他的数据赋值给新数组

缺点：数组原本是存放数据的，删除元素后，数组长度变短

public class Test06{

	public static void main(String[] args){
		
		//原数组
		String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
		
		//新数组
		String[] newNames = new String[names.length-1];
		
		//将原数组的数据迁移到新数组中，要删除的元素(深田咏美)除外
		int index = 0;//新数组的下标
		for(String name:names){
			if(!name.equals("深田咏美")){
				newNames[index] = name;
				index++;
			}
		}
		
		//将新数组的地址赋值给原数组
		names = newNames;
		
		//遍历原数组
		for(String name:names){
			System.out.println(name);
		}
	}
}

第二种方法：将后面的数据依次往前覆盖然后给最后一个数据赋值null

public class Test07{
	
	public static void main(String[] args){
		
		//原数组
		String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
		
		//数据的迁移
		for(int i = 1;i<names.length-1;i++){
			names[i] = names[i+1];
		}
		names[names.length-1] = null;
		
		//遍历原数组
		for(String name:names){
			System.out.println(name);
		}
	}
}

1.7 数组的参数和返回值

public class Test08{
	
	//需求：设计一个方法，传入数组，返回最大值和最小值
	public static void main(String[] args){
		
		int[] is = {1,2,3,4,5,6};
		
		int[] newArr = method(is);
		System.out.println("最大值为：" + newArr[0]);
		System.out.println("最小值为：" + newArr[1]);
	}
	
	public static int[] method(int[] is){
		int max = is[0];
		int min = is[0];
		for(int i = 1;i<is.length;i++){
			if(max < is[i]){
				max = is[i];
			}
			if(min > is[i]){
				min = is[i];
			}
		}
		return new int[]{max,min};
	}
}

1.8 可变参数

public class Test09{
	
	//需求：设计一个方法，传入五个int值，求和
	public static void main(String[] args){
		
		int sum = add(1,2,3,4,5,6,7);//实参作为元素，压入到数组中
		System.out.println(sum);
	}
	
	//is就是数组
	public static int add(int... is){
		int sum = 0;
		for(int num : is){
			sum += num;
		}
		return sum;
	}
	//注意：可变参数后不能接其他参数 
    //错误
	public static void method(int a,String... ss){}
}

2.Arrays工具类

import java.util.Arrays;
public class Test11{	
	/**
		知识点：Arrays工具类
		Arrays：java给我们提供的专门操作数组的工具类
		工具类：类里的所有方法都是静态的（直接使用类名调用）
		API：java类的使用说明书
	*/
	public static void main(String[] args){
		
		int[] is = {39,77,27,20,45,62};
		
		//排序: 20 27 39 45 62 77
		Arrays.sort(is);
		
		//查找(返回值：如果元素在数组中就返回下标，否则返回 -插入点-1 )
		int index =  Arrays.binarySearch(is,42);
		System.out.println("查找元素的下标为：" + index);
		
		//替换
		Arrays.fill(is,888);
		Arrays.fill(is,1,4,666);
		
		//拷贝
		int[] copyOf = Arrays.copyOf(is,is.length*2);
		int[] copyOfRange = Arrays.copyOfRange(is,3,8);
		
		//获取数组的字符串表示(将数组转换为字符串)
		System.out.println(Arrays.toString(copyOfRange));
	}
}

3.二维数组

含义：包含了多个一维数组
声明：数据类型[][] 数组名;
数组的初始化：
静态初始化：数据由程序员指定，长度由系统自动分配

public class Test01 {
    public static void main(String[] args) {

        //静态初始化1
        //String[][] names = new String[][]{{"深田咏美","爱田奈奈","京香julia"},{"明日花绮罗","小峰由衣","泽村丽子","小泽玛利亚"}};

        //静态初始化2
        //String[][] names;
        //names = new String[][]{{"深田咏美","爱田奈奈","京香julia"},{"明日花绮罗","小峰由衣","泽村丽子","小泽玛利亚"}};

        //静态初始化3
        String[][] names = {{"深田咏美","爱田奈奈","京香julia"},{"明日花绮罗","小峰由衣","泽村丽子","小泽玛利亚"}};
        //设置指定下标上的元素
        names[0][2] = "山上悠亚";

        //获取指定下标上的元素
        String name = names[0][2];
        System.out.println("获取指定下标上的元素：" + name);

        //获取长度
        System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
        System.out.println("获取二维数组中第一个一维数组的元素个数：" + names[0].length);//3
        System.out.println("获取二维数组中第二个一维数组的元素个数：" + names[1].length);//4

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

        //遍历 - for循环
        for (int i = 0; i < names.length; i++) {
            for (int j = 0; j < names[i].length; j++) {
                System.out.println(names[i][j]);
            }
        }
        System.out.println("------------");

        //遍历 - foreach
        for (String[] strings : names) {
            for (String string : strings) {
                System.out.println(string);
            }
        }
    }
}

动态初始化：长度由程序员指定，数据由系统赋默认值

public class Test02 {

	public static void main(String[] args) {
		
		//动态初始化1
		//String[][] names = new String[2][3];//2个一维数组，每个一维数组中有3个元素
		
		//动态初始化2
		String[][] names;
		names = new String[2][3];//2个一维数组，每个一维数组中有3个元素
		
		//设置指定下标上的元素
		names[0][0] = "aa";
		names[0][1] = "bb";
		names[0][2] = "cc";
		names[1][0] = "dd";
		names[1][1] = "ee";
		names[1][2] = "ff";
		
		//获取指定下标上的元素
		String name = names[0][2];
		System.out.println("获取指定下标上的元素：" + name);
		
		//获取长度
		System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
		System.out.println("获取二维数组中第一个一维数组的元素个数：" + names[0].length);//3
		System.out.println("获取二维数组中第二个一维数组的元素个数：" + names[1].length);//4
		
		System.out.println("------------");
		
		//遍历 - for循环
		for (int i = 0; i < names.length; i++) {
			for (int j = 0; j < names[i].length; j++) {
				System.out.println(names[i][j]);
			}
		}
		
		System.out.println("------------");
		
		//遍历 - foreach
		for (String[] strings : names) {
			for (String string : strings) {
				System.out.println(string);
			}
		}
	}
}

需求：使用动态初始化二维数组，其中第一个一维数组有3个元素，第二个一维数组有4个元素

public class Test03 {
    public static void main(String[] args) {
        //动态初始化：标注二维数组中有2个一维数组
        String[][] names = new String[2][];

        //把长度为3的一维数组赋值给二维数组中下标为0的位置
        names[0] = new String[3];
        //把长度为4的一维数组赋值给二维数组中下标为1的位置
        names[1] = new String[4];

        System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
        System.out.println("获取二维数组中第一个一维数组的元素个数：" + names[0].length);//3
        System.out.println("获取二维数组中第二个一维数组的元素个数：" + names[1].length);//4
    }					
}