javaEE学习记录Day07

Day07

数组

（这一天学的是一维数组）

1.数组的说明

为什么使用数组？方便处理批量相同类型的数据

数组的概念：一组连续的存储空间，存储多个相同的数据类型的值。

数组声明：数据类型[ ] 数组名；

数组元素：组成数组的基本单元

注意:
1.数组是引用类型
2.每个元素都有编号又叫做下标（下标从0开始）
3.数组初始化时开辟一串连续的空间，初始化后此空间不会改变
（数组没有扩容或删除，后面提到的扩容是通过新建的数组进行一系列操作来达到原数组“扩容”的效果）
4.下标不能超过数组长度，也不能是负数，否则会出现数组下标越界异常（ArrayIndexOutOfBoundsException）
5.数组中的元素的类型一定要和此数组的类型一致

2.数组的初始化

静态初始化：数据由程序员指定，长度由系统根据数据个数开辟空间

public class S{
	
	public static void main(String[] args){
		//静态初始化1
		//String[] n = new String[]{"学","习","很","快","乐"};
		
		//静态初始化2
		//String[] n;
		//names = new String[]{"学","习","很","快","乐"};
		
		//静态初始化3
		String[] n = {"学","习","很","快","乐"};
		
		//设置指定下标上的元素
		n[2] = "多";
		
		//通过下标获取元素
		String a = n[2];
		System.out.println("通过下标获取元素"+a);
		
		//获取元素个数（获取数组长度）
		int len = n.length;
		System.out.println("获取元素个数"+a);
		
		//遍历-for循环
		for(int i=0;i<n.length;i++){
			System.out.println(n[i]);
		}
		//遍历-foreach（增强for循环）
		for(String e :n){//依次遍历n数组中的元素，每次循环就将赋值给e变量
			System.out.println(e);
		}
	}
}

动态初始化：长度由程序员指定，数据由系统根据数组类型赋默认值（整数类型：0，浮点类型：0.0，字符类型：’ ’ （一个空格），布尔类型：false，引用类型：null）

public class S{
    public static void main(String[] args){
            //动态初始化1
            //String[] names = new String[5];//5 - 开辟5个连续的空间，系统会给默认值null

            //动态初始化2
            String[] names;
            names = new String[5];//5 - 开辟5个连续的空间，系统会给默认值null

            //设置指定下标上的元素
            names[0] = "学";
            names[1] = "习";
            names[2] = "快";
            names[3] = "乐";
            names[4] = "吗";

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

应用场景：在一开始就知道数据的情况使用静态初始化；一开始就知道长度，但随着代码的运行才知道具体数据类型的情况使用动态初始化。

3.数组的排序（先了解冒泡排序和选择排序）

冒泡排序：N个数排序，两两相比小靠前，外层循环条件i<N-1，内层循环条件j<N-1-i（这是升序，降序另说）

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

        int[] a={4,7,9,3,2,1,6,5,8};

        for(int i=0;i<a.length-1;i++){
            for(int j=0;j<a.length-1-i;j++){
                if(a[j]>a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        for(int i :a){//输出排序结果
            System.out.println(i);
        }
    }
}

选择排序（升序）

固定位置的值（从首位开始）与其他位置的值做比较，每次比较将得到的最小的值放在这个固定位置，比较完过后此位置的值不会再参与下轮比较，每次确定一个数，最后一轮确定两数，所以需要比较的次数是数组的长度减一

public class S {

	public static void main(String[] args) {
		
		int [] num ={5,3,2,1,4};
		for (int i = 0; i < num.length-1; i++) {//首次是将num[0]的值和其他位置的值做比较
			for (int j = i+1; j < num.length; j++) {
				if(num[i]>num[j]){
					int temp = num[i];
					num[i] = num[j];
					num[j] = temp;
				}
			}
		}
		for (int i : num) {//遍历
			System.out.println(i);
		}
	}
}

4.数组的查找

顺序查找：从头到尾遍历查找，数据庞大时效率低下

public class S{
	
	public static void main(String[] args){
		
		int[] a={4,7,9,3,2,1,6,5,8};
		int num = 5;//要查找的数
		for(int i=0;i<a.length;i++){
			if(num == a[i]){
				System.out.println("找到该数！");
			}
		}
        
	}
}

二分法查找：先排序，再二分（将数组一分为二），效率高

import java.util.Arrays;//引用java给我们提供的工具类
public class S{
	
	public static void main(String[] args){
		
		int[] a={4,7,9,3,2,1,6,5,8};
		int num = 5;
		Arrays.sort(a);//对a进行排序（结果是升序）
		
		int start = 0;
		int end = a.length-1;
		
		while(start<=end){
			int mid =(start+end)/2;
			if(num<a[mid]){
				end = mid-1;
			}else if(num>a[mid]){
				start = mid+1;
			}else{
				System.out.println("找到该数");
				break;
			}
		}
	}
}

5.数组的复制

避免直接将原数组的地址赋值给新数组，因为修改原数组会影响到新数组

public class S{
	
	public static void main(String[] args){
		
		String[] a={"小明","小红","小亮"};//原数组
		
		String[] b= new String[a.length];//新数组
		
		for(int i=0;i<a.length;i++){//数据的转移
			b[i] = a[i];
		}
		for(String c :b){//遍历
			System.out.println(c);
		}
	}
}

6.数组的"扩容"

public class S{
	
	public static void main(String[] args){
		
		String[] a={"小明","小红","小亮"};//原数组
		
		String[] b= new String[a.length*2];//新数组
		
		for(int i=0;i<a.length;i++){//数据的转移
			b[i] = a[i];
		}
		
		a = b;//将新数组在堆里的内存地址赋值给原数组
		
		for(String c :b){//遍历
			System.out.println(c);
		}
	}
	
}

7.数组的"删除"

public class S{
	
	public static void main(String[] args){
		
		String[] a={"小明","小红","小亮"};
		
		for(int i=0;i<a.length-1;i++){
			a[i] = a[i+1];//数据-"小明"消失
		}

		a[a.length-1]=null;
        
		for(String c :a){//遍历
			System.out.println(c);
		}
	}
}

8.数组参数和返回值

现要求创建一个方法，传入int类型的数组，返回最大值与最小值

public class S{
	
	public static void main(String[] args){
		
		int[] a={8,9,0,7,4,5,1,2,3,6};
		int[] b=method(a);
		System.out.println("最大值为"+b[0]);
		System.out.println("最小值为"+b[1]);
		
	}
	public static int[] method(int[] c){
		int max = c[0];
		int min = c[0];
		for(int i=0;i<c.length-1;i++){
			if(max<c[i]){
				max = c[i];
			}
			if(min>c[i]){
				min = c[i];
			}
		}
		return new int[]{max,min};
	}
}

可变参数：在不确定传入参数个数时使用，使用时可变参数后面不能加其他参数。

public class S{
	
	public static void main(String[] args){
		int sum = method(1,2,3,4,5);//计算这5个数之和
		System.out.println(sum);
	}
    //可变参数就是数组
	public static int method(int...a){//将实参作为数组元素传入到a数组中
		int sum = 0;
		
		for(int i:a){
			sum += i;
		}
		return sum;
	}
	
}