1.多维数组
多维数组的元素又是数组,可以有二维、三维、甚至更多维数组
1.1二维数组的声明:
数据类型 [][] = new 数据类型[一维长度][二维长度]
public
1.2 二维数组的初始化:(动态初始化和静态初始化)
public class Test02 {
public static void main(String[] args) {
//二维数组不是规则的矩阵
//二维数组的静态初始化 数据类型[][] 数组名 = new{{值1,值2,...},{值1,值2,...},{值1,...}...}
int [][] arrA = {{1,2},{12,13,14},{1,2,3,4,5}};
System.out.println(arrA);
//声明一个二维数组,存储3个一维数组,每个一维数组长度不清楚
int [] arrB[] = new int[3][];
arrB[0] = new int[2];// 2个 null
arrB[1] = new int[]{1,2,3,4};
arrB[2] = new int[3];
System.out.println(arrB);
//声明一个二维数组,同时创建出一维数组,每个一维数组长度相同
int arrC[][] = new int[3][4];//存储3个一维数组,每个一维数组长度为4
System.out.println(arrC);
}
}
1.3 数组的遍历:
1)普通for循环
2)加强for循环
3)普通for循环+加强for循环
public class Test03 {
public static void main(String[] args) {
int [][] arrA = {{1,2},{2,3,4},{1,2,3,4,5}};
//普通for循环
for(int i=0;i<3;i++) {
for(int j=0;j<arrA[i].length;j++) {
System.out.print(arrA[i][j]+"t");
}
System.out.println();
}
System.out.println("--------####----------------");
//加强for循环
for(int[] arr:arrA) {
for(int i:arr) {
System.out.print(i+"t");
}
System.out.println();
}
System.out.println("-----------****--------------");
//普通for循环与加强for循环混搭
for(int[] arr:arrA) {//加强for
for(int i=0;i<arr.length;i++) {//普通for
System.out.print(i+"t");
}
System.out.println();
}
System.out.println("===================&*&========");
//
for(int i=0;i<arrA.length;i++) {//普通for
for(int j:arrA[i]) {//加强for
System.out.print(j+"t");
}
System.out.println();
}
}
}
1.4 数组的实例实现:(杨辉三角)---------数组及循环嵌套
public class YangHui {
public static void main(String[] args) {
int [][] arr = new int[6][6];
for(int i=0;i<arr.length;i++) {
arr[i][0] = 1;//第一列数字为1
arr[i][i] = 1;//对角线元素为1
}
//其它各元素的值
for(int i=2;i<arr.length;i++) {
// for(int j=1;j<arr.length;j++) {
for(int j=1;j<arr[i].length;j++) {
arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
}
}
//遍历数组,进行打印
for(int i=0;i<arr.length;i++) {
// for(int j=0;j<arr[i].length;j++) {
for(int j=0;j<i;j++) {
System.out.print(arr[i][j]+"t");
}
System.out.println();
}
}
}
1.5 数组存储表格数据
public class Person {
private String name;
private int age;
private char sex;
//构造函数
public Person(String name, int age, char sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return name+"t"+age+"t"+sex;
}
public static void main(String[] args) {
//创建Person类型的数组,用于存储3个Person类型的对象,用于封装信息
Person[] pers = new Person[3];
//创建Person类的对象
Person p1 = new Person("张三",37,'男');
pers[0] = p1;//将p1对象存储到Person类型的数组中去
pers[1] = new Person("王五",16,'男');
pers[2] = new Person("李梅",15,'女');
for(int i=0;i<pers.length;i++) {
System.out.println(pers);//对象数组中存储的是对象的引用(内存地址)
System.out.println(pers[i]);
}
}
}
内存分析:
1.6 数组的拷贝
在System类里也包含了一个
static void arraycopy(object src,int srcpos,object dest, int destpos,int length)方法,
该方法可以将src数组里的元素值赋给dest数组的元素,其中srcpos指定从src数组的第几个元素开始赋值,length参数指定将src数组的多少个元素赋给dest数组的元素
public class Test03 {
public static void main(String[] args) {
int [] arrA = {11,22,33,44};
int [] arrB = new int[5];
System.out.println("数组拷贝之前:");
for(int num:arrB) {
System.out.print(num+"t");
}
System.arraycopy(arrA, 0, arrB, 0, 4);
System.out.println("n数组拷贝之后:");
for(int num:arrB) {
System.out.print(num+"t");
}
}
}
另外,数组的拷贝方法还有:
a.引用(地址)的拷贝
public class Test01 {
public static void main(String[] args) {
int[] arrA ={11,22,33,44};
int [] arrB = new int[5];
//拷贝地址(引用)之前
System.out.println("拷贝之前:");
System.out.println("arrA:"+arrA);
System.out.println("arrB:"+arrB);
//拷贝地址之后
arrB = arrA;
System.out.println("拷贝之后:");
System.out.println("arrA:"+arrA);
System.out.println("arrB:"+arrB);
}
}
b. 值的拷贝
public class Test02 {
public static void main(String[] args) {
int [] arrA = {11,22,33,44};
int [] arrB = new int[5];
//赋值
// arrB[0] = arrA[0];
// arrB[1] = arrA[1];
// arrB[2] = arrA[2];
// arrB[3] = arrA[3];
System.out.println("赋值之前:");
for(int i=0;i<arrB.length;i++) {
System.out.print(arrB[i]+"t");
}
//赋值
int length = Math.min(arrA.length,arrB.length);
for(int i=0;i<length;i++) {
arrB[i] = arrA[i];
}
System.out.println("n赋值之后");
for(int i=0;i<arrB.length;i++) {
System.out.print(arrB[i]+"t");
}
}
}
c. Arrays.copyOf方法,如下:
1.7 java.util.Arrays类
在java.util.Arrays类中,包含了常用的数组操作(排序、查找、填充、打印内容等)
package com.sxt.arrays;
import java.util.Arrays;
public class Test01 {
public static void main(String[] args) {
int[] arrA = {11,16,6,154,36};
int[] arrB = {11,16,6,154,36};
//Arrays.toString 打印数组元素
System.out.println(Arrays.toString(arrA));
System.out.println("------------------------");
System.out.println(arrA.equals(arrB));//比较引用地址
//Arrays.equals 比较内容是否一致
System.out.println(Arrays.equals(arrA,arrB));//比较内容
System.out.println("=========================");
int [] arrC = new int[5];
System.out.println("拷贝前:"+arrC);
System.out.println("-------------------------");
//Arrays.copyOf 开辟新的数组来复制指定的数组
arrC = Arrays.copyOf(arrA, 7);
System.out.println("拷贝后:"+arrC);
System.out.println(Arrays.toString(arrC));
System.out.println("=========================");
//Arrays.fill 将数组中所有元素都已指定元素填充
Arrays.fill(arrC, 88);
System.out.println(Arrays.toString(arrC));
System.out.println("--------------------------");
//sort 将数组中元素按照升序进行排序
Arrays.sort(arrA);
System.out.println("arrA的升序排列:"+Arrays.toString(arrA));
System.out.println("==============");
int [] arr = {5,13,19,21,37,56,64,75,80,88,92};
//折半查找并返回找到元素的下标;未找到则返回值(-插入点-1)
System.out.println(Arrays.binarySearch(arr,21));
System.out.println(" ");
//对Person类型的数组进行排序
Person [] pers = new Person[3];
pers[0] = new Person("张弎",29,'男');
pers[1] = new Person("张大",19,'女');
pers[2] = new Person("张五",49,'男');
System.out.println("按照年龄的升序排列:");
Arrays.sort(pers);
for(Person p:pers) {
System.out.println(p);
}
}
}
class Person implements Comparable<Person> {
private String name;
private int age;
private char sex;
//构造函数
public Person(String name, int age, char sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
}
@Override
public String toString() {
return name+"t"+age+"t"+sex;
}
@Override
public int compareTo(Person o) {//大于 正数,小于负数,等于0
return this.age -o.age ;
}
}
2. 冒泡排序及冒泡排序的优化
2.1冒泡排序算法大致思路:
1. 比较相邻的元素。如果第一个比第二个大,就交换顺序;
2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数;
3. 每一趟循环都从数列的第一个元素开始比较,依次比较相 邻的两个元素,比较到数列的最后;
4. 循环往复,即可得到升序的数组。
图示:
package com.sxt.bubble;
import java.util.Arrays;
//冒泡排序
public class Bubble01 {
public static void main(String[] args) {
int [] arr = {45,13,56,94,16,2,90};
System.out.println("排序前:"+Arrays.toString(arr));
for(int i=0;i<arr.length-1;i++) {//比较的轮数
for(int j=0;j<arr.length-1;j++) {
//相邻两数比较
if(arr[j]>arr[j+1]) {
//通过变量交换
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println("排序后:"+Arrays.toString(arr));
}
}
2.2 冒泡排序的优化算法
将整个数组分成两部分:有序数列和无序数列,因此:
1.不必每一趟都比较到数组结束,到有序数列即可
2.定义一个 boolean 类型的变量 flag,默认有序 true;发生交换,置为 false,一趟循环结束后,根据 flag 的值判断是否有序,有序,则退出循环
3.设置成员变量,放在大循环外部,不必每次都开辟空间
图例:
package com.sxt.bubble;
import java.util.Arrays;
//冒泡排序的优化
public class Bubble02 {
public static void main(String[] args) {
int [] arr = {2,13,16,56,45,90,94};
int temp;
boolean flag;
int count = 0;
System.out.println("排序前:"+Arrays.toString(arr));
for(int i=0;i<arr.length-1;i++) {//比较的轮数
flag = true;//默认有序
count++;//统计比较的次数
for(int j=0;j<arr.length-1-i;j++) {//不需要比较到数组的最后,只需要比较到无序部分即可
//相邻两数比较
if(arr[j]>arr[j+1]) {
//通过变量交换
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
flag = false;//数组中的元素无序,发生了交换
}
}
if(flag) {
System.out.println(flag);
break;//数组有序,退出循环,证明数组有序
}
}
System.out.println("排序后:"+Arrays.toString(arr));
System.out.println("一共比较了"+count+"轮");
}
}