JAVA学习笔记——第六章 数组

🔥博客主页：?A_SHOWY
🎥系列专栏：力扣刷题总结录?数据结构??云计算??数字图像处理??力扣每日一题_?

数组可以存放多个同一类型的数据，是一种数据类型，是引用类型

即：数组就是一组数据

double total = 0;     
double[] hens = {1,2.1,3.2,5,6,7,9};
for(int i = 0; i < 7; i++){
total += hens[i];
System.println.out("total");
}

数组的长度：数组名.length。

数组的使用

使用方式1： 动态初始化

数组的定义：数据类型 数组名【】 = new 数据类型【大小】例：int a【】= new int【5】；

数组的引用（使用）： 数组名【index】?a【2】（获取第三个元素）

例：

import  java.util.Scanner;
public class shuzu1 {
    public static void main(String[] args){
      //输入
        double scores[] = new double[5];
       Scanner myscanner = new Scanner(System.in);
       for(int i = 0; i < scores.length;i++){
           System.out.println("请输入第" + (i+1) + "个元素的值");
           scores[i] = myscanner.nextDouble();
       }
       //输出
        for(int i = 0;i < scores.length;i++){
            System.out.println("第" + (i+1) + "个数组的元素是" + scores[i]);
        }
    }
}

使用方式2： 动态初始化

先声明数组：数据类型 数组名【】也可以? ?数据类型【】? 数组名 例：int a【】或者int【】a

创建数组 ： 数组名 = new 数据类型【大小】 a = new int【10】

使用方式3： 静态初始化

初始化数组：数据类型数组名【】 =? {元素值，元素值。。。。}

数组的注意事项

1. 数组是多个相同类型数据的组合，实现针对数据统一管理?
2. 数组元素可以是任何数据类型，也可以放引用数据类型
3. 数组创建后没有确定的值，有默认值：int：0，short：0，byte：0，long：0，float：0.0，double：0.0，char：0000，boolean：false，String： null
4. 使用数组的步骤，先声明数组开辟空间，然后给各个元素赋值，最后使用
5. 数组的下标从0开始，数组必须指定范围，不能越界
6. 数组是引用类型，数组型数据是对象

例：

import  java.util.Scanner;
public class shuzu2 {
    public static void main(String[] args){
        //输入
     char[] chars = new char[26];
     for(int i = 0; i < chars.length;i++){
         chars[i] = (char)('A' + i);//'A' + i 是int类型，需要强制类型转换
     }
     //输出
        for(int i = 0; i < chars.length; i++){
            System.out.println(chars[i]);
        }
    }
}

?例2：

import  java.util.Scanner;
public class shuzu3 {
    public static void main(String[] args){
       int[] arr = {4,-1,9,10,23};
       int Max = arr[0];
       int index = 0;
       for(int i = 0; i< 5; i++){
           if(arr[i] > arr[index]){
               Max = arr[i];
               index = i;
           }
       }
       System.out.println(Max);
       System.out.println(index);
    }
}

?数组赋值机制

基本数据类型赋值的时候，这个值就是具体的数值且互不影响，赋值方式是值拷贝。而数组在默认情况下是引用传递，赋值是地址，赋值方式为为引用拷贝。

import  java.util.Scanner;
public class shuzu4 {
    public static void main(String[] args){
      int arr1[] = {1,2,3};
      int arr2[] = arr1;
      arr2[0] = 10;
      //看看arr1的值
        for(int i = 0; i < 3; i++){
            System.out.println(arr1[i]);
        }
    }
}

局部变量在栈内存，堆内放实例变量，方法区放静态变量，类方法

在内存里面只要分配了一个空间，一定会有一个地址

数组拷贝

?实现数组拷贝，进行一个内容的复制

      int arr1[] = {1,2,3};
      int arr2[] = arr1;
      int arr3[] = new int[arr1.length];//数组拷贝
      for(int i = 0; i < arr3.length; i++){
          arr1[i] = arr3[i];
      }

数组逆转?

import  java.util.Scanner;
public class shuzu5 {
    public static void main(String[] args){
        int arr[] = {11,22,33,44,55,66};
        int arr1[] = new int[arr.length];
        for(int i = arr.length -1, j = 0; i >= 0; i--, j++){
            arr1[j] = arr[i];
        }
        arr = arr1;//让arr1指向arr 的数据空间，arr原来的数据空间就没有变量引用，就会被当成垃圾销毁
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
     }
}

数组扩容

数组扩容整体是比较慢的，因为每次都要开辟一个新的空间

import  java.util.Scanner;
public class shuzu6 {
    public static void main(String[] args){
        Scanner myscanner = new Scanner(System.in);
        int arr1[] = {1,2,3};
//整体用一个do-while结构，先加一个，然后再问加不加
       do{
           int addarr[] = new int[arr1.length + 1];//每次添加都要开辟一个新空间，创建一个新数组
           System.out.println("请输入你想要添加的数字");
           int xin = myscanner.nextInt();
           for(int i = 0; i < arr1.length; i++){
               addarr[i] = arr1[i];
           }
           addarr[arr1.length] = xin;
           arr1 = addarr;
           //查看扩容后
           for(int i = 0; i < arr1.length; i++){
               System.out.println(arr1[i]);
           }
           System.out.println("请输入y/n表示是否还要增加元素");
           char a = myscanner.next().charAt(0);
           if(a == 'n') break;
       }
       while(true);
    }
}

冒泡排序

冒泡排序：通过对待排序列从后向前，依次比较相邻元素的值，若发现逆序则交换，使数值较大的元素逐渐从前移到后部。

思路：

? 灵活的冒泡排序实现：

import  java.util.Scanner;
public class maopao {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
       System.out.println("请输入想要排序的数组元素个数");
       int num = scanner.nextInt();
        int arr[] = new int[num];
//输入想要的数组的每一个元素
        for(int i = 0; i < num; i++){
            System.out.println("请输入第" + (i+1) +"个元素");
            int num1 = scanner.nextInt();
            arr[i] = num1;
        }
//外层代表循环次数
       for(int k = 1; k < num; k++) {
           for (int i = 0,j = 1; i <= (num - k - 1); i++, j++) {
               if (arr[i] > arr[j]) {
                   int temp = arr[i];
                   arr[i] = arr[j];
                   arr[j] = temp;
               }
           }
           System.out.print("==第" + k + "次循环==");
           for(int i = 0 ; i < num; i++){
               System.out.print(arr[i] + "  ");
           }
           System.out.println('\n');
       }

    }
}

?查找

1.顺序查找

2.二分查找：要求是有序的

二维数组

形式：int【包含几个一维数组】【每个一维数组包含几个元素】 ，二维数组可以理解为每一个元素都是一维数组

二维数组输出：

import java.util.Scanner;
public class erweishuzu {
    public static void main(String[] args){
      int a[][] = {{0,0,0,0,0,0},{0,0,1,0,0,0},{0,2,0,3,0,0},{0,0,0,0,0,0}};
      for(int i = 0; i < a.length; i++){
          for(int j = 0; j < a[i].length; j++){
              System.out.print(a[i][j]);
          }
          //换行
          System.out.println();
      }
    }
}

二维数组的使用

使用方式1：动态初始化? ?

类型【】【】 = new? 类型 【大小】【大小】?例：int a【】【】=new int【2】【3】

?使用方式2：动态初始化?

先声明再初始化，和一维很类似

?使用方式3：动态初始化-列数不确定

import  java.util.Scanner;
public class shuzu7 {
    public static void main(String[] args){
       int[][] arr = new int[3][];//每个一维数组还没有开数据空间
       for(int  i = 0; i < arr.length; i++){//遍历每一个一维数组
           arr[i] = new int[i + 1];//给每一个一维数组开空间new
           for(int j = 0; j < arr[i].length; j++){//遍历每个一维数组，并给他们赋值
               arr[i][j] = i + 1;
           }
       }
    }
}

?使用方式4：静态初始化

和一维数组的非常相似?.

杨辉三角

杨辉三角就用到这种列数不确定

import  java.util.Scanner;
public class yanghui {
    public static void main(String[] args){
        int[][] yanghui= new int [5][];
        for(int i = 0; i < yanghui.length; i++){//遍历yanghui的每个元素
            //给每一个一维数组开辟空间
            yanghui[i] = new int[i + 1];
            //给每个一维数组赋值
            for(int j = 0; j < yanghui[i].length; j++){
                if(j == 0 || j == yanghui[i].length -1){
                    yanghui[i][j] = 1;
                }
                else{
                    yanghui[i][j] = yanghui[i - 1][j] + yanghui[i - 1][j - 1];
                }
            }
        }
        //输出
        for(int i = 0 ;i < yanghui.length;i++){
            for (int j = 0; j < yanghui[i].length; j++){
                System.out.print(yanghui[i][j] + "\t");
            }
            System.out.println();//空格
        }
    }
}

练习1：

?

?C选项之所以错了是可以理解为new的是一个String你初始化为{}是一个数组，所以不对。

练习2（重要）：

有两种思路，第一种是先扩容以后再冒泡排序

import  java.util.Scanner;
public class zuoye3 {
    public static void main(String[] args){
      int[] arr= {10,12,45,90};
      //先扩容
      int[] arr1 = new int[arr.length + 1];
      for(int i = 0; i <arr.length; ++i){
          arr1[i] = arr[i];
      }
      arr1[arr.length] = 23;
      arr = arr1;
      //再冒泡
        for(int k = 0 ; k < 4; k++) {
            for (int i = 0, j = 1; j <=arr.length -1; ++i,++j){
                if(arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
      for(int i = 0; i < arr.length;i++){
          System.out.print(arr[i] + "\t");
      }
    }
}

?第二种思路是先找到这个添加的地方，先定位，这个定位操作用到一个index = -1考虑到有可能插入到最后，然后进行插入

import  java.util.Scanner;
public class zuoye3_2 {
    public static void main(String[] args){
        int arr[] = {10,12,45,90};
        int insertNum = 23;
        int index = -1;
//先找index位置
        for(int i = 0; i < arr.length;i++){
            if(insertNum <= arr[i]){
                index = i;
                break;
            }
        }
//index可能是最大的
        if(index == -1){
            index = arr.length;
        }
//插入
        int arrnew[] = new int[arr.length + 1];
        for(int i = 0, j = 0;i < arrnew.length;i++){
            if(i != index){
                arrnew[i] = arr[j];
                j++;
            }
            else{
                arrnew[i] = insertNum;
            }
        }
        arr = arrnew;
//输出
        for(int i = 0; i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
    }
}