java基础--2.基本语法-2

六、一维数组

         数组是多个相同类型数据的组合，实现对这些数据的统一管理

         数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型

         数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量

 

1.声明

         type var[] 或type[]  var

2.初始化

(1)动态初始化：

         数组声明且为数组元素分配空间与赋值的操作分开进行

         int[] arr = new int[3];

         arr[0] = 3;

         arr[1] = 9;

         arr[2] = 8;

 

(2)静态初始化：

         在定义数组的同时就为数组元素分配空间并赋值。

         int[] a = {3,9,8};

 

public class TestArray {
    public static void main(String[] args) {
       //1.定义一个数组
       //1.1数组的声明
       String [] names;
       int [] scores;      

       //1.2初始化
       //第一种静态初始化
       names = new String[]{"老兰" , "坑爹", "付款"};

       //第二种动态初始化
       scores = new int[4];

       //2.调用数组元素
       scores[0] = 87;      //下角标从 0 ~ n-1
       scores[2] = 88;
       scores[3] = 86;

       //3.数组的长度
       System.out.println("数组长度 = "+scores.length);

       //4.遍历元素
       System.out.print("遍历：");
       for (int i = 0; i < scores.length; i++) {
           System.out.print(scores[i] + " ");
       }
    }
}

 

3.默认初始值

 

4.遍历

(1)传统—适合所有类型

for( 初始化 ; 判别式 ; 更改表达式 ) { }

 

(2)foreach--String

for( 元素类型 元素变量 ：遍历对象) { }

 

      for(inti = 0; i < scores.length; i++) {
         System.out.print(scores[i] + " ");
      }     // 87 0 88 86

      for (String str : names) {
         System.out.print(str + " ");
      }     //老兰 坑爹付款

 

5.一维数组的内存结构

 

 

 

6.创建数组

(1) 创建基本数据类型数组

public class Test{
    public static void main(String args[]){
          int[] s;
          s = new int[10];
          //int[]s=new int[10];
          //基本数据类型数组如果没有赋初值，
          //Java自动给他们赋默认值。
          for ( int i=0; i<10; i++ ) {
              s[i] =2*i+1;
             System.out.println(s[i]);
          }
     }
  }

(2)创建对象数组

 

class MyDate{
        private int day;
        private int month;
        private int year;
        public MyDate(int day, int month, int year) {
           super();
           this.day = day;
           this.month = month;
           this.year = year;
       }
       public void display(){
       System.out.println(year + "-" + month + "-" + day);
        }
 }

 

七、二维数组

 

1.声明并初始化

 

格式1（动态初始化）：int[][] arr = new int[3][2];

格式2（动态初始化）：int[][] arr = new int[3][];

格式3（静态初始化）：int[][] arr = newint[][]{{3,8,2},{2,7},{9,0,1,6}};

 

2. 如何引用一个具体元素

 

int [][] i = new int[3][2];

i[1][0] = 90;

i[2][1] = 100;

 

3.遍历

 

public class Test{
    public static void main(String args[]){
       int [] soores1 = new int[10];
       int [][] scores2 ;
       String[][] names ;

       //1.二维数组初始化
       scores2 = new int [][]{{1 ,2,3},{4 , 5},{6}};//静态初始化

       names = new String[6][5];//动态初始化一
       names = new String[6][];//动态初始化二
       names[0] = new String[1];       //每个二维数组中的一维数组长度可以不一样长
       names[1] = new String[4];
       names[2] = new String[11];
       names[3] = new String[9];
       names[4] = new String[5];
       names[5] = new String[10];

       //2.如何引用一个具体元素
       int [][] i = new int[3][2];
       i[1][0] = 90;
       i[2][1] = 100;

       //3.数组的长度
       System.out.println(i.length);       //3    横向.长度
       System.out.println(i[0].length);    //2

       //4.遍历二维数组
       for (int m = 0; m < scores2.length; m++) {    //控制行数
           for (int n = 0; n < scores2[m].length; n++) {
              System.out.print(scores2[m][n] + " ");
           }
           System.out.println();
       }
    }
}

 

4.二维数组的内存结构

 

 

 

八、数组的常用算法

 

1.求数组元素的最大值、最小值、平均数、总和等

 

//数组最大值
   public int getMax(int[] arr) {
      int max = arr[0];
      for (int i = 1; i < arr.length; i++) {
         if (max < arr[i]) {
            max= arr[i];
         }
      }
      return max;
   }

   //数组的最小值
   public int getMin(int[] arr) {
      int min = arr[0];
      for (int i = 1; i < arr.length; i++) {
         if (min > arr[i]) {
            min= arr[i];
         }
      }
      return min;
   }

   // 遍历数组元素
   public void printArray(int[] arr) {
      System.out.print("[");
      for (int i = 0; i < arr.length; i++) {
         System.out.print(arr[i] + "\t");
      }
      System.out.println("]");
   }

   //数组平均数
   public int avg(int[] arr) {
      int sum = getSum(arr);
      return sum / arr.length;
   }

   // 数组的总和
   public int getSum(int[] arr) {
      int sum = 0;
      for (int i = 0; i < arr.length; i++) {
         sum+= arr[i];
      }
      return sum;
   }

   

 

2.数组的复制、反转

 

// 数组的反转
   public int[] reverse(int[] arr) {
      for (int x = 0, y = arr.length - 1; x < y; x++,y--) {
         int temp = arr[x];
         arr[x]= arr[y];
         arr[y]= temp;
      }

      return arr;
   }

   //数组的复制
   public int[] copy(int[] arr) {
      // int[] arr1 = arr;
      // return arr1;
      int[] arr1 = new int[arr.length];
      for (int i = 0; i < arr.length; i++) {
         arr1[i]= arr[i];
      }
      return arr1;
   }

3.数组元素的排序

 

// 数组的排序
   public void sort(int[] arr, String desc) {
      if (desc == "asc") {     //从小到大
         for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j +1]) {
                   swap(arr,j,j+1);
                }
            }
         }
      }elseif(desc == "desc"){   //从大到小
         for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] < arr[j +1]) {
                   swap(arr,j,j+1);
                }
            }
         }
      }else{
         System.out.println("你输入的排序方式有误");
      }
   }


   public void swap(int[] arr,int i,int j){
      int temp = arr[i];
      arr[i]= arr[j];
      arr[j]= temp;
   }

 

九、Arrays类

Arrays.sort(arr);

System.out.println(Arrays.toString(arr));