学习笔记之Java篇（0729）-CSDN博客

本文链接：https://blog.csdn.net/m0_70630166/article/details/140777165

p 数组

大纲	知识点
数组的概念	数组的定义、四个特点
数组的常见操作	普通遍历、for-each遍历、java.util.Array类用法
多维数组	多维数组的内存结构、存储表格、Javabean和数组存储表格
常见算法	冒泡排序基础算法、冒泡排序优化算法、二分法查找（折半查找）

请添加图片描述

1、数组的特点

数组是相同类型数据的有序集合。其中，每一个数据称作一个元素，每个元素可以通过一个索引」（下标）来访问它们。数组的四个基本特点：

度是确定的。数组一旦被创建，它的大小就是不可以改变的。
其元素的类型必须是相同类型，不允许出现混合类型。
数组类型可以是任何数据类型，包括基本类型和引用类型。
数组变量属于引用类型，数组也是对象，数组中的元素相当于对象的属性！

2、创建数组和初始化

数组的声明方式

type[]  arr_name;//方式一
type  arr_name[]; //方式二

注意事项

声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这是才与长度有关
声明一个数组的时候并没有真正被创建。
构造一个数组，必须指定长度

package com.Index.Array;

public class CreateArray {
  public static void main(String[] args) {
    int a[];
    a = new int[10];
    for (int i = 0; i < 10; i++) {
      a[i] = i* 2 + 1;
    }
    for(int i = 0; i < 10; i++){
      System.out.println(a[i]);
    }

    Man m1 = new Man(1,11);
    Man m2 = new Man(2,22);
    Man m[] = new Man[5];
    m[0] = m1;
    m[1] = m2;
    System.out.println(m[0].getAge());
    System.out.println(m[0].getId());

  }
}
class Man{
  private int id;
  private int age;
  public Man(int id, int age) {
      super();
    this.id = id;
    this.age = age;
  }

  public int getId() {
    return id;
  }

  public int getAge() {
    return age;
  }
}

请添加图片描述
3、初始化

数组的初始化：静态初始化、动态初始化、默认初始化

3.1 静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int[] a = {1,2,3};
Man[] m = {new Man(1,1),new Man(2,2),new Man(3,3),};

3.2 动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

int[] a1=newint[2]://动态初始化数组，先分配空间；
a1[0] = 1://给数组元素赋值；
a1[1]=2://给数组元素赋

3.3 默认初始化

数组是对象，它的元素相当于对象的属性；每个元素也按照属性的方式被默认初始化。

4、数组的常见操作 请添加图片描述
1．遍历指的就是“通过循环遍历数组的所有元素”

2.拷贝指的是将某个数组的内容拷贝到另一个数组中

注：实质上，后面大家学容器的扩容就是“数组的拷贝”。

for-each循环

for-each专门用于读取数组或集合中所有的元素，即数组进行遍历。

package com.Index.Array;

public class For_each {
  public static void main(String[] args) {
    String ss [] = {"aa","bb","ccc","ddd"};
    for(String temp : ss){
      System.out.print(temp+"\t");
    }
  }
}
//运行结果：aa	bb	ccc	ddd

注意事项：
for-each增强for循环在遍历数组过程中不能修改数组中某元素的值。
for-each仅适用于遍历，不涉及有关索引（下标）的操作。

数组拷贝

System.arraycopy(object src,int srcos,object dest,int length)
    //该方法可以将src数组里的元素值赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的元素。

请添加图片描述
java.util.Array类

Arrays类包含了：排序、查找、填充、打印内容等常见的数组操作。

使用Arrays类输出数组中的元素

package com.Index.Array;

import java.util.Arrays;

import static java.lang.System.arraycopy;

public class ArrayCopy {
  public static void main(String[] args) {
    String ss [] = {"aa","bb","ccc","ddd"};
    String s [] = new String[4];
    System.arraycopy(ss,0,s,0 , ss.length);
    for(String sss:s){
      System.out.println(sss);
    }
    System.out.println(Arrays.toString(s));;
    int a[] = {23,1,54,23,66,9,0,43};
    System.out.println("==========================Arrays.sort========================");
    Arrays.sort(a);
      //toString
    System.out.println(Arrays.toString(a));
    /*使用二分法查找*/
    System.out.println("==========================Arrays.binarySearch========================");
    System.out.println("该元素的索引时："+Arrays.binarySearch(a,12));

  /*使用Arrays类对数组进行填充 ，左闭右开*/
    System.out.println("==========================Arrays.fill========================");
    Arrays.fill(a,2,4,100);
    System.out.println(Arrays.toString(a));
  }
}

请添加图片描述
菜鸟雷区

此处的Arrays.toString()方法是Arrays类的静态方法，不是前面讲的Object的toString()方法。

5、多维数组

多维数组可以看成以数组为元素的数组。以有二维、三维、甚至更多维数组，但是实际开发中用的非常少。最多到二维数组（学习容器后，我们一般使用容器，二维数组用的都很少。

请添加图片描述

6、数组存储表格数据
我们观察表格，发现每一行可以使用一个一维数组存储：

Object[] a1 = {1001,"高淇",18,"讲师","2-14"};

Object[］ a2 ={1002,"高小七",19,"助教","10-10"};

Object[］ a3 ={1003,"高小琴",20,"班主任","5-5"};

注意事项

此处基本数据类型“1001”，本质不是Object对象，JAVA编译器会自动把基本数据类型“自动装箱”成包装类对象。

Object[][] emps = new Object[3][ ];
       emps[0] = a1;
       emps[1] = a2;
       emps[2] = a3;

package com.Index.Array;


import java.util.Arrays;

public class ArrayTable {
  public static void main(String[] args) {
    Object a1[] = {1001,"高琪",18,"讲师","2-14"};
    Object a2[] = {1002,"高小其",23,"助教","10-10"};
    Object a3[] = {1003,"高小琴",20,"班主任","5-5"};
    Object emp [][] = new Object[3][];
    emp[0] = a1;
    emp[1] = a2;
    emp[2] = a3;
    System.out.println(Arrays.toString(emp[0]));
    System.out.println(Arrays.toString(emp[1]));
    System.out.println(Arrays.toString(emp[2]));

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

请添加图片描述
7、Comparable接口
Comparable接口中只有一个方法：

public int compareTo (Object obj) //obj为要比较的对象

方法中，将当前对象和obj这个对象进行比较，如果大于返回1，等于返回0，小于返回-1.(此处的1也可以是正整数，－1也可以是负整数)。compareTo方法的代码也比较固定：

package com.Index.Array;

import java.util.Arrays;

public class compare {
  public static void main(String[] args) {
    Man2 m[] = {
            new Man2(23,"a"),
            new Man2(2,"b"),
            new Man2(43,"c")
    };
    System.out.println(Arrays.toString(m));
    Arrays.sort(m);
    System.out.println(Arrays.toString(m));
  }
}
class Man2 implements Comparable{
    int age;
    String name;
    int id;
  public Man2 (int age, String name) {
    this.age = age;
    this.name = name;
  }
  public int compareTo(Object o){
    Man2 man2 = (Man2)o;
    if(this.age < man2.age){
      return -1;
    }
    if(this.age > man2.age){
      return 1;
    }
    return 0;
  }

  public String toString (){
    return this.name;
  }
  public int getAge() {
    return age;
  }

  public String getName() {
    return name;
  }

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

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

请添加图片描述
8、冒泡算法

通过动画可视化数据结构和算法 - VisuAlgo：

冒泡排序的基础算法

冒泡排序算法重复地走访过要排序的数列一次比较两个元素如果他们的顺序错误就把他们交换过来，这样越大的元素会经由交换慢慢“浮”到数列的顶端。冒泡排序算法的运作如下：

较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

package com.Index.Array;

import java.util.Arrays;

public class BubbleSort {
  public static void main(String[] args) {
  int a[] = {0,1,2,3,5,9,4,8,6,7};
//    System.out.println("优化前：");
//    bubbleSortBefor(a);
    System.out.println("优化后：");
    bubbleSort(a);
  }
//  优化前
  public static void bubbleSortBefor(int[] arr) {
    int tmp;
    for(int  i = 0; i < arr.length -  1;i++){
      for (int j = 0; j < arr.length - i - 1; j++) {
        if(arr[j] > arr[j+1]){
          tmp = arr[j];
          arr[j] = arr[j+1];
          arr[j+1] = tmp;
        }
      }
      System.out.println((i+1)+"趟排序："+ Arrays.toString(arr));
    }

  }

// 优化后
  public static void bubbleSort(int[] arr) {
    int tmp;
    for(int  i = 0; i < arr.length -  1;i++){
//      定义一个布尔类型的变量，标记数组是否已达到有序状态
      boolean flag = true;
//      内层循环：每一趟循环都从数列的前两个元素开始进行比较，比较到无序数组的最后
      for (int j = 0; j < arr.length - i - 1; j++) {
        if(arr[j] > arr[j+1]){
          tmp = arr[j];
          arr[j] = arr[j+1];
          arr[j+1] = tmp;
          flag = false;
        }
      }
//      根据标记量的值判断数组是否有序，如果有序，则退出；无序，则继续循环。
      if (flag)
      {
        break;
      }
      System.out.println((i+1)+"趟排序："+ Arrays.toString(arr));
    }

  }
}

请添加图片描述

9、二分检索（binary search)（折半检索）

package com.Index.Array;

import java.util.Arrays;
import java.util.Scanner;

public class BinarySort {
  public static void main(String[] args) {
    int arr[] = {43,12,54,123,54,6,34,92,541,90,10,22,33};
    System.out.println("输入你要查找的数字：");
    Scanner sc = new Scanner(System.in);
    int index  = sc.nextInt();
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
    int Index = BinartSort(arr,index);
    if(Index == -1) System.out.println("无此元素");
    else
    System.out.println( "索引为"+Index );

  }

  public static int BinartSort(int a[], int index){
    int low = 0;
    int height = a.length - 1;
    while(low <= height){
      int mid = (low + height)/2;
      if(a[mid] > index){
        height = mid  - 1;
      }
        if(a[mid] < index){
        low = mid + 1;
      }
        if (a[mid] == index){
          return mid;
        }
    }
    return -1;
  }
}