小白进阶第四天

数组

1、什么是数组

       存储相同的 数据类型的容器

2、数组的特点

（1）相同数据类型

（2）有序的（有下标，从零开始）

（3）数组的长度不可变

3、声明数组

     数组元素的数据类型[]

     数组名：引用变量    

 int[] nums;     
 int nums[]；

4、创建数组（申请内存）

   数组名=new 数据元素的类型[长度];

  

 nums=new int[10];

5、存放数据

    

 nums[0]=1;    
 nums[9]=2;

6、使用数据    

System.out.println（nums[0]）;     
   for(int i=0;i<=nums.length;i++){       
    System.out.println（nums[i]）;       
    }

增强for循环：  for（String s:args）是foreach的形式，表示取出数组args[] 中的每一个元素，循环一次，就取出一个元素赋值给s，直到取完为止。

 for（int n ：nums）{      
     System.out.println(n);    
   }     
      Arrays.toString(nums);

 

7、练习   求数组元素的和

      

 int sum=0;        
   for(String str:args) {            
      sum+=Integer.parseInt(str);                    
    }         
     System.out.println(sum);    
   }  

8、数组的拷贝和克隆

      

int[] a= {1,2,3,4,5};        
int[] b=new int[10];        
//b={1,2,3,0,0,0,……};        
// 数组的拷贝       
 //arraycopy   system类的静态方法        
//第一个参数：原数组          
//第二个参数：原数组元素的起始位置        
//第三个参数：目标数组        
//第四个参数：目标数组元素的起始位置        
//第五个参数：拷贝元素的长度
//        System.arraycopy(a, 0, b, 0, 3);
//        System.out.println(Arrays.toString(b));                
//练习：b={0,0,3,4,0,0,……}       
 System.arraycopy(a,2,b,2,2);        
  System.out.println(Arrays.toString(b));   

9、数组的扩容

       

 //copyOf        
//第一个参数：原数组（拷贝）        
//第二个参数：扩容之后的长度        
String[] names= {"张三"};               
names=Arrays.copyOf(names, names.length+1);        
names[1]="李四";        
System.out.println(Arrays.toString(names));

10、数组的排序

    （1）冒泡排序：两两比较，大的沉下去，小的浮上来，从小到大

       

//冒泡排序
	public static void test1() {
		int[] a= {26,56,22,15,12};
		
		//Arrays.sort(a);
		
		for(int i=0;i<=a.length-1;i++) {
			for(int j=0;j<a.length-i-1;j++) {
				if(a[j]>a[j+1]) {
					if(a[j]>a[j+1]) {
						int temp=a[j];
						a[j]=a[j+1];
						a[j+1]=temp;
					}									
				}	
				
			}
			System.out.println(Arrays.toString(a));
			
			
		}
		//System.out.println(Arrays.toString(a));
	}

（2）选择排序

//选择排序
	public static void test2() {
		int[] nums={26,56,22,15};
		for(int i=0;i<nums.length-1;i++){
            for(int j=i+1;j<nums.length;j++){
                     if(nums[i]<nums[j]){
                        int temp=nums[i];
                        nums[i]=nums[j];
                        nums[j]=temp;
              }
            }
          }
		System.out.println(Arrays.toString(nums));
	}

11、二维数组（有几个括号就是几维）

    声明：
     int[][] arrays;
     int[] arrays;
     int arrays [][];
     
    创建：
    arrays=new int[2][3];     //两行三列
    
    赋值：
    arrays[0][2]=1;
    

     使用数组元素，使用嵌套循环：arrays.length 获取行数

for(int i=0;i<arrays.length;i++){
       for(int j=0;j<arrays[0].length;j++){
             print(arrays[i][j]+"\t");
    }
        println();
      }

举例：    

     int [] a[],b;   //a是二维数组，b是一维数组
     int [] c=new int [2];
     int [][] d=new int [2][3];
    a=c;  err
    b=c; ok
    a=d;  ok
    b=d;  err
    a[0]=c;  ok
    a[0]=err

12、方法

（1）方法的定义：

   [访问修饰符  修饰符] 方法返回类型  方法名（形参列表）{方法体；}
      public   
      private  没有修饰符  
      protected（在继承包的不同关系也可访问）
    static
    public static
    返回类型：无返回值void，有返回值的任何数据类型
     

public static void sum（）{
         System.out.println("求和")；
         return；  //表示方法结束
     }

   如果方法有返回值，那么必须有return   返回值；

public static int sum（）{
       return  1+2.0； 
    }

    public static int[]/object f(){
        return new int[1];
      }

    方法名：同变量名
    形参列表：同变量定义，多个参数用，分开

     方法体：就是方法完成的功能代码

public static int sum（int x，int y）{
        return x+y；
     }

   （2）方法的调用

     方法名（实参列表）

     sum（21，56）；

   （3）方法的重载

     同一个类（继承关系）
     方法名相同，参数列表不同（个数，类型，顺序），一组方法叫做方法重载   和方法的返回类型无关

         public void f（int x）{}
         public int  f（int y）{return x+y；}   //err
         public void f（int x，int y）{return x+y；}   //ok

    （4）值传递

public static void f(int n) {
		n=3;		
	}
	public  static void f2(int[] a) {
		a[0]=9;		
	}
	public  static void f3(int[] a1) {
		a1=new int [5];
		a1[0]=9;		
	}
	public static void main(String[] args) {
		int n=5;
		f(n);
		System.out.println(n);  //5
		
		int a[]= {1,2,3,4,5};
		f2(a);
		System.out.println(a[0]);   //9
		
		int[] a1= {1,2,3,4,5};
		f3(a1);
		System.out.println(a1[0]);   //1
		
	}

13、经典案例

（1）对角线求和

       1    2    3

       1    2    2

       3    2    2

public static void test4() {
		int nums[][]= {{1,2,3},{1,2,2},{3,2,2}};
		int sum=0;
		for(int i=0;i<=nums.length-1;i++) {
			for(int j=0;j<=nums.length-1;j++) {
				//if(i==j)||(i+j==2)
				if((j!=1)&&(i!=1)) {
					sum+=nums[i][j];
				}
			}
			
		}
		System.out.println(sum+nums[1][1]);
	}

public static void test4_1() {
		int nums[][]= {{1,2,3},{1,2,2},{3,2,2}};
		int sum=0;
		for(int i=0;i<=nums.length-1;i++) {
			for(int j=0;j<=nums.length-1;j++) {
				if((i==j)||(i+j==2)) {
					sum+=nums[i][j];
				}
			}
		}
		System.out.println(sum);
	}

（2）矩阵转换

原    1 2 3          
       4 5 6          
现1  4
    2  5
    3  6

public static void test5() {
		int nums[][]= {{1,2,3},{4,5,6}};
		int temp[][]=new int [3][2];
		for(int i=0;i<nums.length;i++) {
		     for(int j=0;j<nums[i].length;j++) {
		    	 temp[j][i]=nums[i][j];
		     }
		}
			for(int i=0;i<temp.length;i++) {
		     for(int j=0;j<temp[i].length;j++) {
		    	 System.out.print(temp[i][j]+"\t");
		     }
		     System.out.println(); 
		     }
			
		}

（3）杨辉三角

public static void test6() {
		Scanner sc =new Scanner(System.in);
		System.out.println("input:");
		int n=sc.nextInt();
		int [][] num=new int [n][];
		
		for(int i=0;i<num.length;i++) {
			num[i]=new int[i+1];
			for(int j=0;j<num[i].length;j++) {
				if(j==0||i==j) {
					num[i][j]=1;
				}else {
					num[i][j]=num[i-1][j]+num[i-1][j-1];
				}
			}		
			
		}
		for(int i=0;i<num.length;i++) {
		     for(int j=0;j<num[i].length;j++) {
		    	 System.out.print(num[i][j]+"\t");
		     }
		     System.out.println(); 
		     }
		
		
	}