java数组学习小笔记

来源：整理的渡一编程的java视频的听课笔记

---

【 数组 】

数组の特点

数组是存储在堆内存中的一串连续的地址，用来存储一组相同数据类型的数据的容器，将一组数据统一管理起来

• 本身是引用数据类型

• 数组内能存储 引用 / 基本 数据类型

• 数组初始化时必须指定 数组长度

• （堆内存）数组长度一旦确定，不再改变

• （栈内存）存储的是地址引用

---

数组定义(声明)

数据类型[] 数组名字

---

数组赋值(初始化)

静态初始化

​ int [] array = new int[] {10,20,30,40,50}

 List<String> List = new ArrayList<String>(); //List
 Iterator<String> it = lisy.iterator; //迭代器

• 有元素内容

动态初始化

​ int [] array = new int[5]

• 有长度

数组长度< 0 异常：NegativeArraySizeException 

---

数组元素访问

​ 通过元素在数组中的位置访问：index索引

[ 0 ~ 数组长度-1 ]

​ 开始 结束

  超出范围异常：ArrayIndexOutofBoundsException

---

数组元素的遍历

增强for循环

for （ 自定义变量名 ： 遍历的数组集合array ）{ }

//增强for循环 ↓  （不使用索引； 只能取，不能存，不能找到具体某值）
	
for (int value : array){
	System.out.println(value);    

}
//普通循环 ↓ （使用索引； 每次输出时，容易因出错而终止输出）
for (int index = 0; index < 5; index++ ){
 int value = array[index];
 System.out.println(value);
}

[ csdn传送门 ]

【 例 】

两个数组元素位置互换

• 对应元素位置互换

• 直接交换数组地址

public class Test{
	// ① 给定两个数组a{1,2,3,4}  b{5,6,7,8} 将两个数组内元素对应位置互换
	public static void main(String[] args){
		//1.创建两个数组
		int[] a ={1,2,3,4};
		int[] b ={5,6,7,8};
		
        //2.元素对应位置互换，每次交换两个数字，换四次
		//方式一：交换数组中对应元素（循环次数好多次，受长度限制）
		/*for(int i=0;i<a.length;i++){   //控制四次
			int x = a[i];
			a[i] = b[i];
			b[i] =x ;		
		}*/
        
		//方式二：直接交换变量a和b中的数组引用(地址)，没有循环 一次搞定 不受长度限制
		int[] temp = a;
		a = b;
		b = temp;
		
        //3.分别输出两个数组元素
		for(int v:a){
			System.out.println(v);		
		}
		System.out.println("--------");
		for(int v:b){
			System.out.println(v);		
		}

	}
}

一个数组元素头尾位置互换

public class Test{
	// ② 给定一个数组a{1,2,3,4,5,6} 将这个数组内元素头尾对应位置互换
	public static void main(String[] args){
		
		int[] array = {1,2,3,4,5,6,7};
        
		for(int i=0; i<array.length/2; i++){
			int x = array[i];
			array[i]= array[(array.length-1)-i];
			array[(array.length-1)-i] = x;
		}
        
		for(int v:array){
			System.out.println(v);		
		}


	}
}

数组最值

public class Test{
	// ④ 给定一个数组 a{1,3,5,7,9,0,2,4,6,8} 找寻数组的最大值和最小值(极值问题)
	public static void main(String[] args){
		int [] a = {1,3,5,7,9,0,2,4,6,8};
		
        //1.创建一个变量 记录信息
		int min=a[0];
		int max=a[0];
		
        //2.挨个寻找数组中的元素，与变量中的元素进行比较
		for( int i=0; i<a.length; i++){
			if(a[i]<min){
				min = a[i];
			}
			if(a[i]>max){
				max= a[i];
			}
		}
		System.out.println("数组中最小值："+min);
		System.out.println("数组中最大值："+max);

	}
}

数组合并

	public class Test{
	// ⑤ 合并两个数组 a{1,2,3} b{4,5}  （创建一个新的数组5长度）
	public static void main(String[] args){
		//1.创建两个数组
		int[] a = {1,2,3};
		int[] b = {4,5};
		
        //2.因为数组长度一旦确定 不能更改 需要创建一个新数组
		int[] newArray = new int[a.length + b.length];  //只有长度 元素默认值0
		
        //3.【思路二】想要将新数组填满
		for(int i=0;i<a.newArray.length;i++){
		if(i<a.length){ //a数组范围内
			newArray[i] = a[i];
		}else{
			newArray[i] = b[i-a.length];
		}
			
		//3.【思路一】分别将a和b数组中的元素存入新数组内
		for(int i=0;i<a.length;i++){//将所有a数组元素存入新数组内
			newArray[i] = a[i];
		} //newArray--->{1,2,3,0,0}
		for(int i=0;i<b.length;i++){//将b数组元素取出来 存入数组后面位置
			newArray[a.length+i] = b[i];
		} //newArray--->{1,2,3,4,5}
		
		//4.验证
		for(int v:newArray){
		System.out.println(v);
		}
	}
}

数组拆分

public class Test{
    // ⑥ 拆分给定数组 a{1,2,3,9,4,5} 按照数组中最大值位置
    public static void main(String[] args){
        //1.需要一个数组
        int[] oldArray = {1,2,3,9,4,5};
        //2.找寻最大值的索引位置  -> 为了通过这个位置 确定两个小数组的长度
        int max = oldArray[0]; //数组的第一个元素值
        int index = 0; //数组的第一个索引位置
        for(int i=1;i<oldArray.length;i++){
            if(oldArray[i]>max){
                max = oldArray[i];
                index = i;
            }
        }
        System.out.println("最大值" + max);
        System.out.println("最大值位置" + index);
        
        //3.需要两个小数组分别承载元素
        int[] newa = new int[index];
        int[] newb = new int[oldArray.length-index-1];
        //4.分别将两个小数组填满
        for(int i=0; i<newa.length;i++){
            newa[i] = oldArray[i];
            index = i;
        }
        for(int i=0; i<newb.length;i++){
            newb[i] = oldArray[(index+1)+i];
            index = i;
        }
        //5.验证
        for(int v:newa){
            System.out.println(v);
        }
        System.out.println("----");
        for(int v:newb){
            System.out.println(v);
        }
    }
}

扩展：多个最大值 - > 新建数组保存数组位置

去掉数组中的0元素

public class Test{		
	//⑦ 给定一个数组a{1,2,3,0,0,4,5,0,6,0,7} 去掉元素中的0元素（创建一个新数组 短的 挑出非零元素）
		//1.需要一个数组
		int[] oldArray = new int[]{1,2,3,0,0,4,5,0,6,0,7};
		//2.找寻原数组中的非零元素个数 -> 才能确定新数组长度
		int count = 0;
		for(int i=0; i<oldArray.length; i++){
			if(oldArray[i]!=0){
				count++;
			}
		}
		System.out.println("原数组中的非零元素个数:" + count);
        //3.创建一个新数组 装载原数组中的非零元素
        int[] newArray = new int[count];  //【思路二】-> 创建一个足够长的数组

        //4.将原数组中非零元素挑出 存入新数组
        int index = 0; //控制新数组的索引变化
        for(int i=0; i<oldArray.length; i++){
            if(oldArray[i]!=0){
                newArray[index++] = oldArray[i];
                //index++;
            }
        }
        //5.旧数组我觉得没有用啦 删掉
        oldArray = null;
        //5.验证
        for(int v:newArray){
            System.out.println(v);
        }
    }  
}

存储2-100素数

思路一

public class Test{
	// ⑧ 创建一个数组 存储2-100间的素数（质数）
	public static void main(String[] args){	
	
        //【思路一：时间长 执行效率低 空间占用率小】
        //0.通过一个几千次循环找寻一个---count
        //1.创建一个数组 长度（刚好的 没有一个空间多余）
        //2.通过一个几千次循环找寻素数 将素数存入数组内
	
        //0.找寻2-100之间素数的个数 -> 确定数组长度
        int count = 0;
        for(int num=2; num<=100; num++){
            boolean b = false; //标识 用来记录最初的状态
            for(int i=2;i<=num/2;i++){ //从2-8之间找寻还有没有其他可以整除的数字
                if(num%i==0){//如果还有能整除的数字 证明num不是素数
                    //System.out.println(num + "不是素数");
                    b = true; //如果满足条件（找到整除 证明不是素数 改变标识
                    break;
                    }
            }		
        if(!b){//如果标识与最初的一致 证明循环内的if从来没有执行过 !b <===> b==false
            //System.out.println(num+"是素数");	
            count++;
        }
        }
        System.out.println("经过找寻，2-100之的素数个数为："+count);		

        //1.创建一个数组 存素数
        int[] primeNumberArray = new int[count];

        //2.找寻2-100之间的素数 将找到的素数存入数组内
        int index = 0; //创建一个新的变量 记录素数数组的索引变化
        for(int num=2; num<=100; num++){
            boolean b = false; //标识 用来记录最初的状态
            for(int i=2;i<=num/2;i++){ //找寻还有没有其他可以整除的数字
                if(num%i==0){//如果还有能整除的数字 证明num不是素数
                    //System.out.println(num + "不是素数");
                    b = true; //如果满足条件（找到整除 证明不是素数 改变标识
                    break;
                    }
            }		
        if(!b){//如果标识与最初的一致 证明循环内的if从来没有执行过 !b <===> b==false
            //System.out.println(num+"是素数");	
            primeNumberArray[index++] = num;			
        }
        }
        //3.验证
        for(int v:primeNumberArray){
            System.out.println(v);
        }
	
	}
}

思路二 √

public class Test{
	// ⑧ 创建一个数组 存储2-100间的素数（质数）
	public static void main(String[] args){	

    //【思路二：时间短  执行效率高 空间占用率长 √】
        //0.创建一个足够长的数组
        //1.通过几千次循环找素数 将素数存入数组
        //2.将存入素数的数组 后面部分0元素去掉
        	
        int[] primeNumberArray = new int[50];
        int index = 0; //记录素数数组的索引变化 同时记录素数个数
        for(int num=2; num<=100; num++){
            boolean b = false; //标识 用来记录最初的状态
            for(int i=2;i<=num/2;i++){ //从2-8之间找寻还有没有其他可以整除的数字
                if(num%i==0){//如果还有能整除的数字 证明num不是素数
                    //System.out.println(num + "不是素数");
                    b = true; //如果满足条件（找到整除 证明不是素数 改变标识
                    break;
                    }
            }		
            if(!b){//如果标识与最初的一致 证明循环内的if从来没有执行过 !b <===> b==false
                //System.out.println(num+"是素数");	
                primeNumberArray[index++] = num;
            }
        }//{2,3,5,7,11,13.....0,0,0,0,0,0,0,0,0,0,}
        int[] newArray = new int[index];
        for(int i=0;i<newArray.length;i++){
            newArray[i] = primeNumberArray[i];
        }
        primeNumberArray = null;
        for(int v:newArray){
            System.out.println(v);
        }
    }
}