标签：数组 int 元素 length ints new

1. 数组概述

数组(array): 存储一个元素个数固定且元素类型相同的有序集

2. 数组的定义格式

• 格式一

  数据类型[] 变量名
  int[] array; -->推荐
  

• 格式二

  数据类型 变量名[]
  int array[];
  

3.数组的初始化

java中的数组必须先初始化才能使用

初始化: 就是为数组中的数据元素分配内存空间,并为每个数组元素赋值

• 静态初始化

  初始化时,指定每个数组元素的初始值,由系统决定数组长度
  
  格式: 数据类型[] 变量名 = new 数据类型[]{元素1,元素2,...};
  int[] array = new int[]{1,2,3};
  
  简化: 数据类型[] 变量名 = {元素1,元素2,...}
  int[] array = {1,2,3}
  
  适合一开始就能确定元素值的业务场景
  

• 动态初始化

  初始化时,只指定数组长度,由系统为数组分配初始值
  
  格式: 数据类型[] 变量名 = new 数据类型[数组长度]
  int[] array = new int[10]
  
  适合知道元素数量,不确定具体元素值的场景
  

4. 数组元素访问

• 数组变量的访问方式

  格式: 数组名
  

• 数组内部保存的数据的访问方式

  数组名[索引]
  
  索引: 数组中数据的编号方式
  作用: 用于访问数组中的数据,数据名[索引],等同于变联名,称为下标变量
  特征: ① 索引从0开始
       ⑤ 索引是连续的
       ③ 索引逐一增加,每次加一
  

5. 数组的常见操作

• 遍历

  什么是遍历?
  获取数组中的每一个元素
  
  获取数组长度(元素个数)
  格式: 数组名.length 
  array.length
  

  //数组遍历的通用格式
  for(int i=0;i<array.length;i++){
      array[i]//对每个元素进行操作
  }
  

• 获取最大值

  思路:
  1. 定义一个变量,用于保存最大值
  2. 取数组中的第一个元素,作为变量的初始值
  3. 与数组中剩余元素逐个比较,每次比较将最大值保存在变量中
  

  int max = array[0];
  for(int i = 1;i<array.length;i++){
      if(array[i]>max){
          max = array[i];
      }
      System.out.println("max:"+max);
  }
  

• 元素打乱

  什么是元素打乱?
  	把数组中的元素随机交换位置,每次运行都可能产生不一样的结果
  	
  获取元素中的随机索引
  	Random random = new Random();
  	int index = random.nextInt(array.length)
  

  Random random = new Random();
  for(int i=0;i<array.length;i++){
      int index = random.nextInt(array.length);
      
      int temp = array[i];
      array[i] = array[index];
      array[index] = temp;
  }
  System.out.println(Arrays.toString(array))
  

6. 数组使用的三个问题

• 指针越界

  访问了数组中不存在的索引对应的元素
  

• 空指针异常

  数组变量不在指向堆内存,还想继续访问数据
  

• 溢出

  操作系统会自动给每个进程分配一个最大栈空间2M
  操作系统会自动给每个进程分配一个最大堆空间4G
  如果数组过大,就会造成堆溢出
  

7. 二维数组概述

元素为一维数组的数组

8. 二位数组的定义格式

• 格式一

  数据类型[][] 变量名;
  int[][] array;  --->推荐
  

• 格式二

  数据类型 变量名[][];
  int array[][];
  

• 格式三

  数据类型[] 变量名[];
  int[] array[];
  

9. 二位数组初始化

• 静态初始化

  格式: 数据类型[][] 变量名 = new 数据类型[][]{元素1,元素2,元素3,...};
  int[][] array = new int[][]{{1,2,},{3,4}};
  
  简化: 数据类型[][] 变量名 = {{1,2},{3,4}} ;
  int[][] array = {{1,2},{3,4}};
  

• 动态初始化

  格式: 数据类型[][] 变量名 = new 数据类型[m][n];
  int[][] array = new int[2][2];
  

10. 二位数组的元素访问

• 获取二位数组

  数组名
  

• 获取一维数组

  数组名[索引]
  

• 获取每个二位数组的元素

  数组名[索引][索引]
  

11. 二维数组的常见操作

• 遍历

  for(int i=0;i<array.length;i++){
      for(int j=0;j<array[i].length;j++){
          System.out.print(array[i][j]+" ");
      }
      System.out.println();
  }
  // 外层循环得到一维数组
  // 内层循环得到每个二维数组的元素
  

• 元素打乱

  Random random = new Random();
  for(int i=0;i<array.length;i++){
      for(int j=0;j<array[i].length;j++)[
          int x = random.nextInt(array.length);
          int y = random.nextInt(array[x].length)
          
          int temp = array[i][j];
          array[i][j] = array[x][y];
          array[x][y] = temp;
      ]
  }
  

12.数组中的常见算法

1. 使用输入值初始化数组
public static void main(String[] args) {
    int[] ints = new int[5];
    Scanner input = new Scanner(System.in);
    System.out.println("Enter"+ints.length+"values:");
    for (int i = 0; i < ints.length; i++) {
        ints[i] = input.nextInt();
    }
    System.out.println(Arrays.toString(ints));
}

2. 使用随机数初始化数组
public static void main(String[] args) {
    int[] ints = new int[10];
    Random random = new Random();
    for (int i = 0; i < ints.length; i++) {
        ints[i] = random.nextInt(20);
    }
    System.out.println(Arrays.toString(ints));
}

3. 显示数组
public static void main(String[] args) {
    int[] ints ={1,2,3,4};
    for (int i = 0; i < ints.length; i++) {
        System.out.print(ints[i]+" ");
    }
}

4. 对所有元素求和
public static void main(String[] args) {
    int[] ints = {1,2,3,4};
    int sum = 0;
    for (int i = 0; i < ints.length; i++) {
        sum += ints[i];
    }
    System.out.println(sum);
}

5.找出最大元素
public static void main(String[] args) {
    int[] ints = {1,2,3,4,89,100};
    int max = 0;
    for (int i = 0; i < ints.length; i++) {
        if (ints[i]>max){
            max = ints[i];
        }
    }
    System.out.println(max);
}

6.找出最大元素的最小下标值
public static void main(String[] args) {
    int[] ints = {1,2,5,4,5,5,};
    int index = 0;
    int max = 0;
    for (int i = 0; i < ints.length; i++) {
       if (ints[i]>max){
           max = ints[i];
           index = i;
       }
    }
    System.out.println(index);
}

7.随机打乱
public static void main(String[] args) {
    int[] ints = {1,2,3,4,5,6,7,8,9,10};
    int temp = 0;
    Random random = new Random();
    for (int i = 0; i < ints.length; i++) {
        int j = random.nextInt(9);
        temp = ints[i];
        ints[i] = ints[j];
        ints[j] = temp;
    }
    System.out.println(Arrays.toString(ints));
}

8.移动元素(向左移动一个元素)
public static void main(String[] args) {
    int[] ints = {1,2,3,4,5};
    int temp = ints[0];
    for (int i = 1; i < ints.length; i++) {
        ints[i-1] = ints[i];
    }
    ints[ints.length-1] = temp;
    System.out.println(Arrays.toString(ints));
}

9.简化编码
public static void main(String[] args) {
    String[] strings = {"one","two","three","four","five","six","seven"};
    Scanner input = new Scanner(System.in);
    System.out.println("Enter a mother number(1 to 7):");
    int num = input.nextInt();
    System.out.println(strings[num-1]);
}

10.编写一个程序,找出所有大小项平均值的项的个数
public static void main(String[] args) {
    int[] ints = {1,2,3,4,5,6,7,8,9,10};
    int sum = 0;
    int temp = 0;
    for (int i = 0; i < ints.length; i++) {
        sum += ints[i];
    }
    int num = sum/ints.length;
    for (int i = 0; i < ints.length; i++) {
        if (ints[i]>num){
           temp++;
        }
    }
    System.out.println(temp);
}

13.数组的复制

1. 使用循环语句,逐个的复制数组中的元素
2. 使用System类中的静态方法arraycopy
3. 使用clone方法复制数组

注意: 不能使用使用赋值语句复制数组,如list1 = list2,它是将list2的引用值复制给了list1,
list1和list2都将指向list2引用的数组,而list1引用的数组将被垃圾回收

1. 使用循环
public static void main(String[] args) {
    int[] ints = {1,2,3,4,5};
    int[] ints2 = new int[ints.length];
    for (int i = 0; i < ints.length; i++) {
        ints2[i] = ints[i];
    }
    System.out.println(Arrays.toString(ints2));
}
2. 使用方法arraycopy
语法: arraycopy(sourceArray, srcPos, targetArray, tarPos, length)
sourceArray: 原数组
targetArray: 目标数组
srcPos: 原数组的复制起始位置
tarPos: 目标数组的复制起始位置
length: 复制的长度

public static void main(String[] args) {
    int[] ints = {1,2,3,4,5};
    int[] ints2 = new int[ints.length];
    System.arraycopy(ints, 0, ints2, 0, ints.length);
    System.out.println(Arrays.toString(ints2));
}

标签：数组,int,元素,length,ints,new
来源： https://www.cnblogs.com/suwuji/p/16521814.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。