7月12日数组的使用

1.数组简介

变量: 存储单个数据
数组: 存储多个数据

数组: 相同数据类型的有序集合
      一段连续的内存空间

特点:
    1.引用数据类型
    2.长度一旦确定不可改变
    3.存储的多个数据要求数据类型一致
    4.数组是有序的

索引|下标:
    第一个空间: 0
    最后一个空间 : 数组名.length-1

数组的长度:
    数组名.length

操作数组中的数据:
    数组名[索引|下标]->确定数组中的某一块空间操作空间中的数据内容



结构:
    数组的声明
        数据类型[]  数组名;  --> 推荐
        数据类型  数组名[];

    数组的初始化
        动态初始化: 先创建数组对象,然后赋值
            数据类型[]  数组名 = new 数据类型[长度];
            数据类型: 任意的数据类型
                     数组中存放数据的类型

            不同类型的数组每一个空间存在默认值:
                整数:0   小数:0.0  布尔: false 字符:空字符  引用: null

        静态初始化: 创建数组对象的同时赋值
            数据类型[]  数组名 = new 数据类型[]{值1,值2,值3...};
            数据类型[]  数组名 = {值1,值2,值3...};

注意:
    1.ArrayIndexOutOfBoundsException 数组索引越界异常

public class Class001_Array {
    public static void main(String[] args) {
        // 声明
        int[] arr1;
        double arr2[];

        //动态初始化
        arr1 = new int[3];
        arr2  = new double[5];

        //为数组赋值
        arr1[0] = 100;
        arr1[1] = 101;
        arr1[2] = 102;

        //获取数组中的数据
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);

        //静态初始化
        String[] arr3 = new  String[]{"张三","李四","王五","赵六"};
        System.out.println(arr3[0]);
        System.out.println(arr3[1]);
        System.out.println(arr3[2]);
        System.out.println(arr3[3]);
        //System.out.println(arr3[4]);

        char[] arr4 = {'a','b','c'};
        System.out.println(arr4[0]);
        System.out.println(arr4[1]);
        System.out.println(arr4[2]);
        System.out.println(arr4.length);
        /*数组中的最后一个数据*/
        System.out.println(arr4[arr4.length-1]);

    }
}

public class Class002_Array {
    public static void main(String[] args) {
       //数据类型[] 数组名 = new 数据类型[长度];
       int[] arr = {1,2,3,4};

       //构建一个存储学生数据的数组
       Student[] stus = new Student[3];

       //学生数据
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",19);
        Student s3 = new Student("王五",17);

        //把学生数据放入数组
        stus[0] = s1;
        stus[1] = s2;
        stus[2] = s3;

        System.out.println(stus);
        System.out.println(stus[0]);
        System.out.println(stus[1]);
        System.out.println(stus[2]);
    }
}

Student{name=‘张三’, age=18}
Student{name=‘李四’, age=19}
Student{name=‘王五’, age=17}

2.数组的遍历

数组的遍历
 1.普通for循环
 2.增强for循环|for..each
    for(数据类型 变量名i:数组名|集合名){
        每一次循环中,i代表数组中的每一个数据
    }

 注意:
    普通循环遍历操作索引,索引控制变化情况
    增强for循环遍历数组,只能从前到后遍历

public class Class003_Each {
    public static void main(String[] args) {
       int[] arr = {1,2,3,4};

       //普通for循环
        //变量控制数组的索引
        for(int i=0;i<=arr.length-1;i++){
            System.out.println(arr[i]);
        }

        //增强for循环
        for(int i:arr){
            System.out.println(i);
        }
    }
}

public class Class004_ArrayPractice {
   public static void main(String[] args){
      //int[] arr = getMaxMin(new int[]{3,2,1,4,5});
      int[] arr = {3, 2, 1, 4, 5};
      printIntArray(arr);
      int[] arr1=getMaxMin(arr);
      System.out.println(arr1[0]);
      System.out.println(arr1[1]);
      print(arr);

   }
   
   //A:遍历int类型的数组 依次输出每个数组元素
   //返回值 : 不需要
   //参数 : int[]
   public static void printIntArray(int[] arr){
      for(int i:arr){
         System.out.println(i);
      }
   }

   //B:遍历字符数组
   public static void printCharArray(char[] arr){
      for(int i=0;i<=arr.length-1;i++){
         System.out.println(arr[i]);
      }
   }
   
   //C:最值:获取数组中的最大值和最小值
   public static int[] getMaxMin(int[] arr){
      //假设数组中的第一个数据为最大值
      int max = arr[0];
      int min = arr[0];

      for(int i:arr){
         if(max<i){
            max = i;
         }
         if(min>i){
            min = i;
         }
      }
      return new int[]{max,min};
   }

   //D:逆序:倒叙输出数组元素
   public static void print(int[] arr){
      for(int i=arr.length-1;i>=0;i--){
         System.out.print(arr[i]);
      }
   }

}

3
2
1
4
5
5
1
54123

3.练习

/*
 * 1.将一个整型数组中的0去掉后但会一个新数组.
 *     例如: int[] arr={1,26,0,8,10,50,8,0,7,35,0,4,3,20,0,17};
 *  要求:将以上数组中的0去掉,将不为0的值存入一个新数组,生成新的数组作为返回值.
 *     int newArr={1,26,8,10,50,8,7,35,4,3,20,17};
 */
public class Class005_ArrayPractice {
   public static void main(String[] args){
      int[] arr={1,26,0,8,10,50,8,0,7,35,0,4,3,20,0,17};

      print(checkZero(arr));

      System.out.println(find(arr,18));
   }

   
   public static int[] checkZero(int[] arr){
      //先找到不为0数据的的个数
      int count = 0;
      for(int i:arr){
         if(i!=0){
            count++;
         }
      }
      //当原数组中不存在0,直接返回值原数组
      if(count==arr.length){
         return arr;
      }

      //创建新数组
      int[] newArr = new int[count];

      //数组数据的拷贝
      int j = 0; //j为新数组的索引
      for(int i : arr){
         if(i!=0){
            newArr[j++] = i;
         }
      }

      //返回新数组
      return newArr;
   }

   /*2.数组元素查找(查找指定元素第一次在数组中出现的索引)
    * 若存在:返回这个元素的下标
    * 若不存在:返回-1
    */
   public static int find(int[] arr,int value){
      for(int i=0;i<arr.length;i++){
         if(arr[i]==value){
            return i;
         }
      }
      return -1;
   }

   //遍历int类型数据的方法
   public static void print(int[] arr){
      for(int i:arr){
         System.out.println(i);
      }
   }


}

126810508735432017-1

public class Class005_ArrayPractice1 {
   public static void main(String[] args){

      testEmp();
   }

   public static void testEmp(){
      //1.构建一个员工数组
      Employee[] arr = {
            new Employee("王玉波",21,20000),
            new Employee("刘本军",18,10000),
            new Employee("王跃虎",20,30000),
            new Employee("郑达",22,15000),
            new Employee("张三",22,2000),
      };

      //1.展示输出所有员工信息
      for(Employee e:arr){
         System.out.println(e);
      }

      //2.找到所有员工的姓名存储起来
      String[] names = new String[arr.length];
      //索引i作为原数组与新数组的索引
      for(int i=0;i< arr.length;i++){
         names[i] = arr[i].getName();
      }
      System.out.println(Arrays.toString(names));

      //3.找到所有薪资>10000的员工->裁员
      //ArrayList 集合结构: 存储多个数据,长度可以根据数据的多少进行增删,有序有索引,存储相同的数据
      ArrayList list = new ArrayList();
      //遍历原数组,找到所有薪资<=10000的员工放入集合list中
      for(Employee e:arr){
         if(e.getSalary()<=10000){
            list.add(e);
         }
      }
      System.out.println(list);

      //4.找到出现的员工年龄,年龄出现的值的可能统计个数
      //HashSet 集合结构: 存储多个数据,无序去重
      HashSet set = new HashSet();
      //获取所有员工的年龄放入set集合,最终统计结合中保留的数据个数
      for(Employee e:arr){
         set.add(e.getAge()); //向集合中添加数据
      }
      System.out.println(set.size());
   }
}
public class Employee {
    //属性:
    private String name;
    private int age;
    private double salary;

    public Employee() {
    }

    public Employee(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age &&
                Double.compare(employee.salary, salary) == 0 &&
                Objects.equals(name, employee.name);
    }

}

4.二维数组

二维数组: 了解
    数组中存放数组

    声明:
        数据类型[][] 数组名;   -->推荐
        数据类型 数组名[][];
        数据类型[] 数组名[];
        数据类型 [][]数组名;

    初始化:
        动态初始化 : 先创建数组然后赋值
            数据类型[][] 数组名 = new 数据类型[外层的二维的长度][内层的一维的长度];
            特点: 内层的每一个一维数组长度相同

            数据类型[][] 数组名 = new 数据类型[外层的二维的长度][];
            特点: 内层的每一个一维数组没有构建,长度有构建的时候指定
                内层的每一个一维数组的创建按照一维数组的创建方式(动态,静态)

        静态初始化 : 创建数组的同时赋值
             数据类型[][] 数组名 = new 数据类型[][]{{值1,值2,值...},{值1,值2,值...},{值1,值2,值...}....};
             数据类型[][] 数组名 = {{值1,值2,值...},{值1,值2,值...},{值1,值2,值...}....};

    操作二维数组中的数据
        数组名[外层二维索引][内层一维的索引]

public class Class001_Array {
    public static void main(String[] args) {
        //动态
        //数据类型[][] 数组名 = new 数据类型[外层的二维的长度][内层的一维的长度];
        int[][] arr1 = new int[2][3];

        //赋值
        arr1[0][0] = 1;
        arr1[0][1] = 2;
        arr1[0][2] = 3;

        arr1[1][0] = 4;
        arr1[1][1] = 5;
        arr1[1][2] = 6;

        System.out.println(arr1[0][0]);
        System.out.println(arr1[0][1]);
        System.out.println(arr1[0][2]);
        System.out.println(arr1[1][0]);
        System.out.println(arr1[1][1]);
        System.out.println(arr1[1][2]);

        //数据类型[][] 数组名 = new 数据类型[外层的二维的长度][];
        double arr2[][] = new double[2][];
        //构建每一个一维数组
        arr2[0] = new double[3];
        arr2[0][0] = 1.1;
        arr2[0][1] = 2.2;
        arr2[0][2] = 3.3;

        arr2[1] = new double[]{3.3,4.4};

        System.out.println(arr2[0][0]);
        System.out.println(arr2[0][1]);
        System.out.println(arr2[0][2]);
        System.out.println(arr2[1][0]);
        System.out.println(arr2[1][1]);

        //静态初始化
        char[][] arr3 = new char[][]{{'a'},{'b','c'},{'d','e','f'}};
        System.out.println(arr3[0][0]);
        System.out.println(arr3[1][0]);
        System.out.println(arr3[1][1]);
        System.out.println(arr3[2][0]);
        System.out.println(arr3[2][1]);
        System.out.println(arr3[2][2]);

        System.out.println(arr3.length);
    }
}

/*
     二维数组的遍历方式:
        1. 普通嵌套普通
        2. 普通嵌套增强
        3. 增强嵌套增强
        4. 增强嵌套普通
 */
public class Class002_Array {
    public static void main(String[] args) {
        //静态初始化
        char[][] arr = new char[][]{{'a'},{'b','c'},{'d','e','f'}};


        //1)普通嵌套增强
        for(int i = 0;i<arr.length;i++){
            for(char ch:arr[i]){
                System.out.println(ch);
            }
        }

        //3. 增强嵌套增强
        for(char[] chars:arr){
            for(char ch:chars){
                System.out.println(ch);
            }
        }

        //普通嵌套普通
        for (int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                System.out.print(arr[i][j]);
            }
        }

        //增强嵌套普通
        for(char[] chars:arr){
            for(int i=0;i<chars.length;i++){
                System.out.print(chars[i]);
            }
        }

    }
}

a
b
c
d
e
f