java学习第八天(数组，以及数组的引用)

青旅半醒 2021-12-19 00:43 259阅读 0赞

数组：数组就是同一种类型的集合，并且有固定的长度，是一组连续的空间。

声明数组的三种方法：

int[]a=new int[3];//开辟一组内存大小为3的数组
    		int[]b={1,2,3};
    		int[]c;
    		c=new int[]{1,2,3};

/*
                    数组中默认数值：
                    基本数据类型的数组：int[] 
                            byte: 0
                            short: 0
                            int: 0
                            long: 0L
                            float: 0.0F
                            double: 0.0
                            char: \u0000 -->空
                            boolean:false
                    
                    引用数据类型的数组：String[]
                        null
                    */

## 数组的赋值： ##

int[0]a=1;//给第一个下标0的位置赋值为1

/*
                    数组中经常遇到的错误：
                    Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4  --》下标为4的位置出错
            at TestArray01.main(TestArray01.java:33)
                    
                    Array   Index   OutOf   Bounds   Exception
                    数组     索引     超出    边界     异常    ----》数组越界异常
                    */

## 数组的特点： ##

1：存放的都是同一种类型的数据。

2：有固定的数组长度。这个长度在声明数组的时候已经开辟好了内存空间。不可改变。

3：数组有下标，从0开始索引到对应的数组值------------数组的长度-1（a.length-1）

4：数组的存放是有序的。

## 数组的优缺点： ##

优点：

1：数组依靠索引遍历比较方便高效。

缺点：

1：数组的长度定义了就不能改变了。

2：数组进行元素插入和删除操作的时候需要大量的移动元素，比较麻烦。

3：数组中存放的元素只能是一种。

4：因为数组的存放是连续的，所以需要大量的堆空间来对数组进行存储。

### 数组练习中去学习： ###

import java.util.*;
    public class TestArr01{
    	public static void main(String[]args){
    		System.out.println("请输入5个学生的成绩");
    		int[]score=new int[5];
    		Scanner sc=new Scanner(System.in);
    		int sum=0;
    		for(int i=1;i<=5;i++){
    			score[i-1]=sc.nextInt();//数组的录入
    			sum+=score[i-1];
    		}
    		
    		for(int i=0;i<=score.length-1;i++){
    			System.out.println("数组的正序输出 "+score[i]+"也可以这样"+Arrays.toString(score));
    		}
    		
    		// 数组的倒叙输出
    		for(int i=score.length-1;i>=0;i--){
    			System.out.println("数组的倒叙输出 "+score[i]);			
    		}
    		
    		// 输出数组中的最大值:1:遍历数组，找个值maxnum，不断的比较
    			int maxnum=score[0];
    			int minnum=score[0];
    			int index=0;//记录最大索引
    		for(int i=0;i<=score.length-1;i++){
    			if(maxnum<=score[i]){
    				maxnum=score[i];
    				index=i;
    			}			
    		}
    		System.out.println("最大值为："+maxnum+"最大索引为"+index);
    	}
    }

## 增强for循环  ##

for(int a:数组)\{

System.out.println(a);

## 练习：在数组中指定索引插入元素，删除最后一个元素 ##

import java.util.*;
    public class TestArr02{
    	public static void main(String[]args){
    		// 在数组中指定索引插入元素，删除最后一个元素
    			/*思想：最后一个要删除，所以从倒数第二个开始往倒数第一个一个一个移位置，直到需要插入数组
    			的前一个*/
    	
    					//给定一个数组：
    		int[] arr={12,23,67,17,34,7,8,4,9,15,29};
    		//         0   1  2  3  4 5 6 
    		
    		//在增加元素前遍历打印一下数组：
    		System.out.println("增加元素前："+Arrays.toString(arr));
    				
    		//在下标为2的位置上增加一个元素：66：
    		/*arr[6]=arr[5];
    		arr[5]=arr[4];
    		arr[4]=arr[3];
    		arr[3]=arr[2];*/
    		int index=4;
    		
    		for(int i=arr.length-1;i>=(index+1);i--){
    				arr[i]=arr[i-1];
    		}
    		
    		arr[index]=999;
    		
    		System.out.println("增加元素后："+Arrays.toString(arr));
    	}
    }

## 练习：删除元素 ##

思想就是从删除元素的后一个索引的位置往删除位置的索引，往前一个一个移，最后一个用0代替即可。

删除指定的索引对应的元素“：
    import java.util.Arrays;
    public class TestArray02{
            public static void main(String[] args){
                    //给定一个数组：
                    int[] arr={12,23,67,17,34,7,8,68,49};
                    //         0   1  2  3  4 5 6 
                    
                    //删除前遍历：
                    System.out.println("删除前："+Arrays.toString(arr));
                    
                    //删除下标为2的元素：
                    /*arr[2]=arr[3];
                    arr[3]=arr[4];
                    arr[4]=arr[5];
                    arr[5]=arr[6];*/
                    //指定要删除的元素的下标：
                    int index=4;
                    
                    for(int i=index;i<=arr.length-2;i++){
                            arr[i]=arr[i+1];
                    }
                    
                    arr[arr.length-1]=0;
                    
                    
                    //删除后遍历：
                    System.out.println("删除后："+Arrays.toString(arr));
            }
    }
    
    
    删除指定元素：
    
    import java.util.Arrays;
    public class TestArray02{
            public static void main(String[] args){
                    //给定一个数组：
                    int[] arr={12,23,67,17,34,7,8,67,49};
                    //         0   1  2  3  4 5 6 
                    
                    //删除前遍历：
                    System.out.println("删除前："+Arrays.toString(arr));
                    
                    //指定要删除的元素的下标：
                    int index=-1;
                    
                    //删除第一个666--》思路：找到第一个67对应的索引即可：
                    for(int i=0;i<=arr.length-1;i++){
                            if(arr[i]==67){
                                    index=i;
                                    break;
                            }
                    }
                    
                    if(index>=0){//如果你找到这个数，就删除
                            //删除指定索引的元素：
                    
                            for(int i=index;i<=arr.length-2;i++){
                                    arr[i]=arr[i+1];
                            }
                            
                            arr[arr.length-1]=0;
                    }else{
                            System.out.println("对不起，没找着");
                    }
                    
                    //删除后遍历：
                    System.out.println("删除后："+Arrays.toString(arr));
            }
    }