java07

java07 数组数组的常见操作数组的遍历数组的拷贝java,util.Arrays类多维数组Comparab接口（定义比较策略）冒泡排序算法二分法查找

数组

• 本质：数组也是对象

• 定义：是相同类型数据的有序集合，每一个元素可以通过一个下标访问

• 特点：

1. 长度是确定的，数组一旦被创建，它的大小就是不可改变的

2. 其元素的数据类型必须是相同类型，不允许出现混合类型

3. 数组类型可以是任何数据类型，包括基本类型和引用类型

4. 数组变量属于引用类型，数组也是对象，数组中的元素相当于对象的属性

• 声明数组的方式：

1. type[] arr_name;

2. type arr_name[];

3. 注：声明的时候没有实例化任何对象

//数组的声明
class Man{private int age;private int id;public Man(int id,int age){super();this.age = age;this.id = id;}
​public int getAge() {return age;}
​public void setAge(int age) {this.age = age;}
​public int getId() {return id;}
​public void setId(int id) {this.id = id;}
}
public class AppMain {public static void main(String[] args) {Man[] mans;//声明引用类型数组mans = new Man[10];//给引用类型数组分配空间Man m1 = new Man(1,11);Man m2 = new Man(2,22);//动态初始化mans[0] = m1;//给引用类型数组元素赋值mans[1] = m2;//给引用类型数组元素赋值System.out.println(mans[0].getId());System.out.println(mans[0].getAge());}
}
​

//数组的声明和创建
public class Test01 {public static void main(String[] args) {int[] s;//声明数组s = new int[10];//给数组分配空间for (int i = 0; i < 10; i++) {s[i]= 2*i+1;System.out.println(s[i]);}}
}

• 三种初始化

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

2. 动态初始化：数组定义与为数组元素分配空间并赋值操作分开进行

3. 默认初始化：数组是对象，它的元素相当于对象的属性，每个元素也被按照实例变量同堂的方式被隐式初始化

//测试数组的三种初始化方式
public class Test02 {public static void main(String[] args) {//静态初始化int[] a = {10,20,30,40};Man mans[] = {new Man(1,10),new Man(2,20),new Man(3,30)};System.out.println(a[1]);System.out.println(mans[2].getAge());//默认初始化int a2[] = new int[2];//默认值：0,0boolean[] b = new boolean[2];//默认值：false，falseString[] s = new String[2];//默认值：null，null}
}

数组的常见操作

数组的遍历

• 遍历指的是“通过循环遍历数组的所有元素”

• 下标合法区间：[0,length-1]

• 通过for循环

//增强for循环遍历数组
public class TestFor {public static void main(String[] args) {String[] ss = {"aa","bb","cc"};for (String temp:ss){System.out.println(temp);}}
}

• for-eac循环：专门用于读取数组或集合中所有的元素

• 注：for-each增强for循环在遍历数组过程中不能修改数组中某元素的值

//测试遍历
public class Test03 {public static void main(String[] args) {String[] cities = {"北京","上海","广州","深圳"};for (int i = 0; i < cities.length; i++) {System.out.println(cities[i]);}//for each只用于简单读取数组的内容for (String t:cities) {System.out.println(t);}}
}

数组的拷贝

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

• 注：容器的扩容就是数组的拷贝

• System.arraycopy(Object src,int srcpos,object dest,int destpos,int length)

//测试拷贝
public class Test04 {public static void main(String[] args) {String[] s = {"ali","shang","jing","sou","wang"};String[] sBak = new String[6];System.arraycopy(s,0,sBak,0,s.length);for (int i = 0; i < sBak.length; i++) {System.out.println(sBak[i]);}}
}

java,util.Arrays类

• 包含了：排序，查找，填充，打印等常见的数组操作

//测试Arrays类
import java.util.Arrays;
public class Test05 {public static void main(String[] args) {int[] a = {1,3};System.out.println(a);//打印数组引用的值System.out.println(Arrays.toString(a));//打印数组元素的值//排序int[] a1 = {1,2,3,4,2};System.out.println(Arrays.toString(a1));Arrays.sort(a1);System.out.println(Arrays.toString(a1));//使用二分法查找int[] a2 = {1,2,343,34,43,12,35};System.out.println(Arrays.toString(a2));Arrays.sort(a2);System.out.println(Arrays.toString(a2));//返回排序后新的索引位置，若未找到返回负数System.out.println("该元素的索引位置："+Arrays.binarySearch(a2,12));
​//对数组元素进行填充int[] a3 = {1,2,333,23,323,12,59};System.out.println(Arrays.toString(a3));Arrays.fill(a3,2,4,100);//将2到4索引的元素替换为100System.out.println(Arrays.toString(a3));}
}

多维数组

• 多维数组可以看成以数组为元素的数组

import java.util.Arrays;
​
//测试多维数组的初始化
public class Test06 {public static void main(String[] args) {//java中多维数组的声明和初始化应按从低维到高维的顺序进行int[][] a = new int[3][];a[0] = new int[2];a[1] = new int[3];a[2] = new int[4];//int a[][] = new int[][4];//非法
​//二维数组的静态初始化、int[][] b = {{1,2,3},{3,4},{3,5,6,7}};System.out.println(b[1][1]);//二维数组的动态初始化int[][] c = new int[3][];//c[0] = {1,2,3};//错误，没有声明类型就初始化c[0] = new int[]{1,2};c[1] = new int[]{2,2};c[2] = new int[]{1,2,6,7};System.out.println(c[2][2]);System.out.println(Arrays.toString(c[0]));System.out.println(Arrays.toString(c[1]));System.out.println(Arrays.toString(c[2]));}
}

• 数组存储表格信息 ：使用javabean和一维数组存储表格信息

import java.util.Arrays;//测试Object【】【】二维数组存储表格数据
public class Test07 {public static void main(String[] args) {Object[] a1 = {111,123,134,145};Object[] a2 = {222,223,234,245};Object[] a3 = {333,323,334,345};Object[][] emps = new Object[3][];emps[0] = a1;emps[1] = a2;emps[2] = a3;System.out.println(Arrays.toString(emps[0]));System.out.println(Arrays.toString(emps[1]));System.out.println(Arrays.toString(emps[2]));//嵌套循环遍历System.out.println("========================");for (int i = 0;i< emps.length;i++){for (int j = 0; j < emps[i].length; j++) {System.out.print(emps[i][j]+"\t");}System.out.println();}}
}

//使用javabean和数组保存表格数据
public class Test08 {public static void main(String[] args) {Emp[] emps = {new Emp(100,"xx",18,"tt","22"),new Emp(200,"jj",18,"ee","33"),new Emp(300,"hh",18,"dd","44")};for (Emp e:emps) {System.out.println(e);}}
}
class Emp{private int id;private String name;private int age;private String job;private String hiredata;public Emp(int id, String name, int age, String job, String hiredata) {this.id = id;this.name = name;this.age = age;this.job = job;this.hiredata = hiredata;}@Overridepublic String toString() {return "Emp{" +"id=" + id +", name='" + name + '\'' +", age=" + age +", job='" + job + '\'' +", hiredata='" + hiredata + '\'' +'}';}public int getId() {return id;}public void setId(int id) {this.id = id;}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 getJob() {return job;}public void setJob(String job) {this.job = job;}public String getHiredata() {return hiredata;}public void setHiredata(String hiredata) {this.hiredata = hiredata;}
}

Comparab接口（定义比较策略）

• java中所有排序都依赖于comparable接口

• compar接口只有一个方法：public int compareTo(Object obj)//obj为要比较的对象

import java.util.Arrays;
//测试Comparable接口
public class Test09 {public static void main(String[] args) {Man2[] msMans={new Man2(3,"a"),new Man2(60,"b"),new Man2(33,"c")};System.out.println(Arrays.toString(msMans));Arrays.sort(msMans);System.out.println(Arrays.toString(msMans));}
}
class Man2 implements Comparable{int age;int id;String name;public Man2(int age,String name){super();this.age = age;this.name = name;}public String toString() {return this.name;}public int compareTo(Object o){Man2 man = (Man2) o;if (this.ageman.age){return 1;}return 0;}
}

冒泡排序算法

package array;import java.util.Arrays;class TestBubbleSort {public static void main(String[] args) {int[] values = {3, 1, 6, 8, 9, 0, 7, 4, 5, 2};System.out.println("原始顺序：" + Arrays.toString(values));
//        bubbleSort(values);bubbleSort2(values);//优化后的冒泡排序算法}public static void bubbleSort(int[] values){int temp;for (int i = 0; i < values.length; i++) {for (int j = 0; j < values.length-1-i; j++) {if (values[j]>values[j+1]){temp = values[j];values[j] = values[j+1];values[j+1] = temp;}}System.out.println((i+1)+"趟排序："+Arrays.toString(values));}}//优化后的冒泡排序//整个数列前面是无序序列，后面是有序序列//public static void bubbleSort2(int[] values) {int temp;for (int i = 0; i < values.length; i++) {boolean flag = true;//内层循环：每一趟循环都从数列的前两个元素开始进行比较，比较到无序数组的最后for (int j = 0; j < values.length - 1 - i; j++) {//如果前一个元素大于后一个元素，则交换两元素的值if (values[j] > values[j + 1]) {temp = values[j];values[j] = values[j + 1];values[j + 1] = temp;//本趟发生了交换，表明该数组在本趟处于无序状态，需要继续比较flag = false;}}if (flag) {break;}System.out.println((i + 1) + "趟排序：" + Arrays.toString(values));}}
}

二分法查找

import java.util.Arrays;public class TestBinarySearch {public static void main(String[] args) {int[] arr = {10,30,56,4,20,85,65,100,12};int searchWord = 20;//所要查找的数Arrays.sort(arr);//二分法查找之前，一定要对数组元素排序System.out.println(Arrays.toString(arr));System.out.println(searchWord+"元素的索引："+binarySearch(arr,searchWord));}public static int binarySearch(int[] arr,int value){int low = 0;int high = arr.length-1;while(low<=high){int middle = (low +high)/2;if (value == arr[middle]){return middle;//返回查询到的索引位置}if (value >  arr[middle]){low = middle+1;}if (value <  arr[middle]){high = middle-1;}}return -1;}
}

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！