Javase数组基础知识

数组

  数组概念：一组连续的存储空间，存储多个相同类型的值。
  特点：连续，类型相同，容量固定。
  数组的创建： int[] a=new int [5];创建一定声明长度。
  
  
  数组的遍历：
   /*声明并分配空间，在内存中申请长度为5的连续空存储5个int类型的值。数据类型[] 数组名=new 数据类型[5]*/
  	public static void main(String[] args) {
	 int a []=new int[5];
	 for(int i=0;i<5;i++){
		a[i]=i*10; 
	 } 
	 /*通过for循环遍历下标从零开始*/
	 for(int i = 0;i<a.length;i++){
		 System.out.print("a"+"["+i+"]"+"="+a[i]+"\t");
	 } 
	}
	
	
 增强for循环：只适合遍历操作(jdk1.5后引人，不能使用下标)
	  for(数组元素类型 n:数组){
	      //n代表数组中的每个元素
	  }
   
 数组的默认值：整数0  小数0.0  字符：\u000  布尔false   其他null
 
 
 数组的创建的方式4种：
   a.先声明、在分配空间
           数组类型[] 数组名；
           数组名=new 数据类型[长度]
   b.声明并分配空间
            int[] a=new int [5]；
   c.声明并赋值
           char [] a;
           a=new char[]{'a','b'};
   d.声明并赋值(简写)
           String a[]={1,2,3,}
  
   
  数组练习题:
      //1.定义一个数组求该数组中所有所有值的平均值：
      double []a={1,2,8,10};
		double sum=0;
		for(int i=0;i<a.length;i++){
			sum+=a[i];
		}
       System.out.println(sum/a.length);
       
       
     //2.给定一个数组，输入一个数N如果数组中有和n相等的数返回其下标反之返回-1
     int []a={1,5,3,7,9,12,1};
		Scanner scanner=new Scanner(System.in);
		int input=scanner.nextInt();
		int flag=0;//设置标识符来判断是否有
		for(int i=0;i<a.length;i++){
			if(a[i]==input){
				flag=1;
				System.out.println(i);
			}
		}
		if(flag==0){
			System.out.println(-1);
		}
		
		
   //3控制台输入5个城市的名给定义的数组，然后在输出：
   	String city []=new String[5];
		Scanner scanner=new Scanner(System.in);
		for(int i=0;i<city.length;i++){
			System.out.println("输入第"+(i+1)+"个城市名：");
			city[i]=scanner.next();
		}
	  for(String n:city){
		  System.out.print(n+"\t");
	  }
	  
	数组的扩容：
	创建数组时，必须显示指定长度，并在创建之后不可更改长度。
	思路：创建大于原来数组的新数组；将原来数组中的元素依次复制到新的数组中去。
	
	
    //数组的扩容(3种)
	int num[] =new int[5];
	 for(int i=0;i<num.length;i++){
		num[i]=i+8;
	 }
	 for(int n:num){
		 System.out.print(n+"\t");
	 }
	 System.out.println();
	 //创建一个比num大的新数组之后旧的数组中的值复制给新的数组
	 int num1[]=new int[num.length*2];
	   for(int i=0;i<num.length;i++){
		   num1[i]=num[i];
	   }  
	 for(int a:num1){
		 System.out.print(a+"\t");
	 }
	 
	 
	 复制方法：
	 System.arraycopy(原数组,原数组起始，新数组，新数组起始，复制元素的个数);
	 
	 java.util.Arrays.copyOf(原数组名，新数组的长度);返回一个新的数组： int []=java.util.copyOf(unms,length*2)
	 
	
	数组类型参数：
	   局部的变量在栈中
	   基本数据类型的传值：
	   在方法中用完就释放。不影响原数据的值。基本数据类型在栈中。一方的改变不会影响另一方的值。
	   
	   引用数据类型的传值：
	   引用数据类型在堆中。方法在栈中加载碰到引用数据类型时会把该引用数据的地址指向栈中。一方的改变会影响另一方。
       
       
	  
	
	数组类型返回值：
	    //采用返回地址的方式给数组扩容
    	public class Arr {
    	public static void main(String[] args) {
        int [] nu={111,222,333,444,555};
        nu=expand(nu);
        for(int n:nu){
        	System.out.print(n+"\t");
        }
        System.out.println();
    	}
        public static int[] expand(int[] arr) {
    		 int [] newNums=new int[arr.length*2];
    		 for(int i=0;i<arr.length;i++){
    			 newNums[i]=arr[i];
    		 }
    		 return newNums;
    	}
      }

	       
	       
	       
	       
	       
	可变长参数：//源码只是一个封装好的数组
	    概念：可接收多个同类型的实参，个数不限，使用方式与数组选相同。
	    语法：数据类型...形参名//只能放在参数的最后而且只能有一个。
        
	    
	数组排序：
	    冒泡排序：
	    //冒泡排序
     public class RankBubble {
    	public static void main(String[] args) {
          int a[]={7,9,2,12,1,45,13};
          System.out.print("原始数：");
          for(int d:a){
        	  System.out.print(d+" ");
          }
          System.out.println();
          for(int i=0;i<a.length;i++){
        	  for(int j=0;j<a.length-i-1;j++ ){
        		   if(a[j]>a[j+1]){
        			   int tem;
        			   tem= a[j];
        			   a[j]=a[j+1];
        			   a[j+1]=tem;
        		   }
        	  }
          }
      	  System.out.print("排序后：");
          for(int n:a){
      
        	  System.out.print(n+" ");
          }
          System.out.println();
    	}
    
    }
	
	
	
	
	选择排序:
	public class XuanZe2 {
      public static void main(String[] args) {
//        一，定义数组：
       int[] arr = {23,54,65,3,5,2,87,33,345,435,11,325,555,121,346,0,20,49,17};
//        二，定义一个临时变量，用来后边交换元素顺序，作中间值；
       int temp = 0;
//        三，开始排序：
//           1），常规操作，先定义一个外循环：（用来控制第一位置元素）
//              只有在多轮内循环之后，才选出第一个位置是最小的数，所以，"第一位置元素"不能随着内循环而变化，而是应该跟着外循环而变化，因为每一轮外循环过后，选出一个“第一位置元素”；所以"第一位置元素"应该是arr[i];
       for (int i = 0; i < arr.length; i++) {
//            2），内循环，让“第一位置元素”依次与后边的元素进行比较；
           for (int j = i+1; j < arr.length; j++) {
//                2.1)如果第一个数大于后边的数，则进行交换；交换之后，j++（继续往后遍历）,此时、此后，仍然是第一个位置的数（arr[i]）与后边的数进行比较；
               if (arr[i] > arr[j]) {
                   temp = arr[j];
                   arr[j] = arr[i];
                   arr[i] = temp;
               }
//                2.2)如果第一个数 不大于 后边的数，则继续遍历后边的下一个数；
               else{
                   continue;
               }
           }
       }
       //        四，打印结果：
       for (int i : arr) {
           System.out.print(i+"----");
       }
   }
}


    jdk排序：java.util.Arrays.sort(数组名)；升序
    
    颠倒循序:
    for(int i=0;ia.length/2;i++){
        int tem=a[i];
        a[i]=a[a.length-i-1];
        a[a.length-i-1]=tem;
    }
      
	
	
	
	
	二维数组（二重循环）：
	概念：一维数组中的一维数组，数组中的元素还是数组。
	定义语法：  数据类型 [] [] 数组名=new  数据类型[行] [列];
	声明:
	a.
	int[] [] nums=news int [3][5];
	存值：
	num[0][0]=10;  //第一行，第一列
    num[0]3[]=20
	b.
	int [] []num;
	num=new int[2][3];
	c.
	列可以不声明，行必须声明几行。
	d.
	int a[][]={{1,3,4,7},{12,11,14},{21,31,41}}
	
	增强型for循环输出二维数组：
	    for(int[] a:num){
	    	for(int s:a){
	    		System.out.print(s+"\t");
	    	}
	    	System.out.println();
	    }