二数组深化

多维数组：

　　二维数组就是存储一维数组的数组

package com.zqf.Array;
public class TestArray {
 public static void main(String[] args) {
  //(1)数组可以存储基本数据类型和引用数据类型
  int [] arrA= {11,22,33,44};  //一维数组，引用数据类型
  /**数据类型 [] 数组名= new 数据类型[长度]*/
  System.out.println(arrA);
  //(2)二维数组存储一维数组的数组
  int [] [] arrB= new int [3][];
  //使用二维数组去存储一维数组
  arrB[0] = arrA;
  System.out.println(arrB);
 }
}

package com.zqf.Array;
   public class TestArray2 {
       public static void main(String[] args) {
       //二维数组不是规则的矩阵
       int [] intA[] = {{1,2},{2,3,4},{3,4,5,6}};
       System.out.println(intA);
  
     //声明一个二维数组，用于存储3个一维数组，每一个一维数组存多少个数组，不知道，null
      int [][]intB= new int[3][];
      intB[0] = new int[3];//3
      intB[1]= new int []{1,2,3,4};
      intB[2] = new int [2]; //2
      System.out.println(intB);
      //声明一个二维数组，同时创建出一维数组，每个一维数组的长度均相同
      //存储三个一维数组，每个一维数组的长度为4
      int []intC[] = new int [3][4];
      System.out.println(intC);
     }
     }

Object数组存储表格数据：

package com.zqf.Array;
public class Object {
 private String name; //姓名
 private int age;   //年龄
 private String gender;   //性别
 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 String getGender() {
  return gender;
 }
 public void setGender(String gender) {
  this.gender = gender;
 }
 
 public Object(String name, int age, String gender) {
  super();
  this.name = name;
  this.age = age;
  this.gender = gender;
 }
 public Object(){
  super();
 }
}

package com.zqf.Array;
public class TestObject {
 public static void main(String[] args ){
  //创建一个Object类型的数组，用于存储3个Object类型的对象
  Object [] o = new Object[3];
  //创建Object类型的对象
  Object o1 = new Object("张三",19,"男");
  o[0] = o1;
  o[1]= new Object("李四",20,"女");
  o[2] = new Object("王五",28,"男");
  for (int i=0;i<o.length;i++){
   System.out.println(o[i]);
  }
  
 }
}

java.util.Arrays工具类的使用

      Arrays类中的常用方法
 1.toString()打印数组
 2.equals比较两个数组是否相同
 3.copyOf(...)复制指定的数组
 4.fill(...)填充
 5.sort(...)数组排序
    对象数组的排序

冒泡排序的基础算法：

package com.zqf.Array;
import java.util.Arrays;
public class TestBubble {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int [] array= {33,11,44,22,55 };
  System.out.println("排序之前的序列"+Arrays.toString(array));
  for(int i=0;i<4;i++){
   for(int j=0;j<4;j++){
    //比较相邻两数
    if (array[j]>array[j+1]){
     //第三变量交换
     int temp = array[j];
     array[j]= array[j+1];
     array[j+1] = temp;
    }
   }
  }
  //排序之后的数组
  System.out.println("排序之后："+Arrays.toString(array));
 }
}

排序之前的序列[33, 11, 44, 22, 55]排序之后：[11, 22, 33, 44, 55]

冒泡优化：

package com.zqf.Array;
import java.util.Arrays;
public class TestBubble2 {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int [] array= {33,11,44,22,55 };
  System.out.println("排序之前的序列"+Arrays.toString(array));
  boolean flag;
  int count = 0;
  for(int i=0;i<array.length-1;i++){          //5个数，比4次，N-1
   flag = true; //默认有序
   count++;   //统计比较的轮数
   //每轮比较的次数
   for(int j=0;j<array.length-1-i;j++){  //无需比较到数组的最后，只需要比较无序数列部分即可
    //两两相比 
    if(array[j]>array[j+1]){
     int temp = array[j];
     array[j]= array[j+1];
     array[j+1] = temp;
     flag = false ;   //数据中的元素无序，发生了交换
    }
   }
   if(flag){
    break; //退出循环，证明数组有序
   }
  }
  //排序之后的数组
  System.out.println("排序之后："+Arrays.toString(array));
  System.out.println("一共比较了"+count+"轮");
 }
}

排序之前的序列[33, 11, 44, 22, 55]

排序之后：[11, 22, 33, 44, 55]
一共比较了3轮