数组
1. 数组的概念
1.1 数组的定义
数组的定义：
数组是相同类型数据的有序集合。
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。
数组的三个基本特点：
- 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
- 其元素必须是相同类型，不允许出现混合类型。
- 数组类型可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属于引用类型，数组也是对象
1.2 创建数组和初始化
1.2.1 数组声明
方式一：type[ ] arr_name
方式二：type arr_name[ ]
注意事项：
1. 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。
2. 声明一个数组的时候并没有数组真正被创建。
3. 构造一个数组，必须指定长度。
【示例】创建基本类型一维数组
public class Test {
public static void main(String args[]) {
int[] s = null; // 声明数组；
s = new int[10]; // 给数组分配空间；
for (int i = 0; i < 10; i++) {
s[i] = 2 * i + 1;//给数组元素赋值；
System.out.println(s[i]);
}
}
}
【练习】数组的定义和初始化
public class Test01 {
public static void main(String args[]) {
//数组的定义和初始化
int[] arr1 = new int[5]; //默认初始化：数组元素相当于对象的属性，遵守对象属性默认初始化的规则
//动态初始化：根据索引直接赋值
System.out.println(arr1[0]);
System.out.println(arr1[1]);
int arr2[] = {20,30,40}; //静态初始化
System.out.println(arr2);
//数组的遍历
for (int i = 0; i < arr1.length; i++) {
arr1[i] = i*2+1;
System.out.print(arr1[i]+"\t");
}
}
}
【示例】创建引用类型一维数组
class Man{
private int age;
private int id;
public Man(int id,int age) {
super();
this.age = age;
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;//给引用类型数组元素赋值；
}
}
1.2.2 初始化
1. 数组的静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
注意：静态初始化需要在声明后直接初始化
int[] a = { 1, 2, 3 };// 静态初始化基本类型数组；
Man[] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；
2. 数组的动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。
int[] a1 = new int[2];//动态初始化数组，先分配空间；
a1[0]=1;//给数组元素赋值；
a1[1]=2;//给数组元素赋值；
3. 数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
int a2[] = new int[2]; // 默认值：0,0
boolean[] b = new boolean[2]; // 默认值：false,false
String[] s = new String[2]; // 默认值：null, null
2. 数组常见操作
2.1 数组的遍历
数组元素下标的合法区间：[0, length-1]。我们可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。
【示例】数组的遍历
public class Test {
public static void main(String[] args) {
int[] a = new int[4];
//初始化数组元素的值
for(int i=0;i<a.length;i++){
a[i] = 100*i;
}
//读取元素的值
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
}
2.2 for-each 循环
增强for循环for-each是JDK1.5新增加的功能，专门用于读取数组或集合中所有的元素，即对数组进行遍历。
【示例】
public class Test {
public static void main(String[] args) {
String[] ss = { "aa", "bbb", "ccc", "ddd" };
for (String temp : ss) {
System.out.println(temp);
}
}
}
注意事项
1. for-each增强for循环在遍历数组过程不能修改数组中某元素的值。
2. for-each仅适用于遍历，不涉及有关索引(下标)的操作。
2.3 数组的拷贝
System类里也包含了一个static void arraycopy(object src，int srcpos，object dest， int destpos，int length)方法，该方法可以将src数组里的元素值赋给dest数组的元素
srcpos指定从src数组的第几个元素开始赋值
length参数指定将src数组的多少个元素赋给dest数组的元素
【示例】数组的拷贝arraycopy( )
public class Test {
public static void main(String args[]) {
String[] s = {"阿里","尚学堂","京东","搜狐","网易"};
String[] sBak = new String[6];
System.arraycopy(s,0,sBak,0,s.length);
for (int i = 0; i < sBak.length; i++) {
System.out.print(sBak[i]+ "\t");
}
}
}
2.4 java.util.Arrays类
JDK提供的java.util.Arrays类，包含了常用的数组操作，方便我们日常开发。Arrays类包含了：排序、查找、填充、打印内容等常见的操作。
【示例】打印数组Arrays.toString( )
import java.util.Arrays;
public class Test03 {
public static void main(String[] args) {
int[] a = {100,200,300};
System.out.println(Arrays.toString(a));
}
}
注意：此处的Arrays.toString()方法是Arrays类的静态方法，不是前面讲的Object的toString()方法。
【示例】数组元素的排列Arrays.sort( )
import java.util.Arrays;
public class Test03 {
public static void main(String[] args) {
int[] a = {1,11,2,22,3,33,12,21,31};
System.out.println(Arrays.toString(a));
Arrays.sort(a);
System.out.println(Arrays.toString(a));
}
}
想对某个类的对象进行比较就需要实现Comparable接口，该接口中只有compareTo()一个方法，这个方法定义了对象之间的比较规则，根据这个规则就能实现对所有对象排序
compareTo方法的代码比较固定，案例：
【示例】compareTo( )
public int compareTo(Object o) {
Man man = (Man) o;
if (this.age < man.age) {
return -1;
}
if (this.age > man.age) {
return 1;
}
return 0;
【示例】数组元素是引用类型的排序(Comparable接口的应用)
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
Man[] msMans = { new Man(3, "a"), new Man(60, "b"), new Man(2, "c") };
Arrays.sort(msMans);
System.out.println(Arrays.toString(msMans));
}
}
class Man implements Comparable {
int age;
int id;
String name;
public Man(int age, String name) {
super();
this.age = age;
this.name = name;
}
public String toString() {
return this.name;
}
public int compareTo(Object o) {
Man man = (Man) o;
if (this.age < man.age) {
return -1;
}
if (this.age > man.age) {
return 1;
}
return 0;
}
}
【示例】二分法查找Arrays.binarySearch( , )
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] a = {1,2,323,23,543,12,59};
System.out.println(Arrays.toString(a));
Arrays.sort(a); //使用二分法查找，必须先对数组进行排序;
System.out.println(Arrays.toString(a));
//返回排序后新的索引位置,若未找到返回负数。
System.out.println("该元素的索引："+Arrays.binarySearch(a, 12));
}
}
【示例】数组填充Arrays.fill( , , , );
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] a= {1,2,323,23,543,12,59};
System.out.println(Arrays.toString(a));
Arrays.fill(a, 2, 4, 100); //将2到4索引的元素替换为100;
System.out.println(Arrays.toString(a));
}
}
3. 多维数组
3.1 多维数组
【示例】二维数组的声明
public class Test {
public static void main(String[] args) {
// Java中多维数组的声明和初始化应按从低维到高维的顺序进行
int[][] a = new int[3][];
a[0] = new int[2];
a[1] = new int[4];
a[2] = new int[3];
// int a1[][]=new int[][4];//非法
}
}
【示例】二维数组的静态初始化
public class Test {
public static void main(String[] args) {
int[][] a = { { 1, 2, 3 }, { 3, 4 }, { 3, 5, 6, 7 } };
System.out.println(a[2][3]);
}
}
内存图：
【示例】二维数组的动态初始化
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[][] a = new int[3][];
// a[0] = {1,2,5}; //错误，没有声明类型就初始化
a[0] = new int[] { 1, 2 };
a[1] = new int[] { 2, 2 };
a[2] = new int[] { 2, 2, 3, 4 };
System.out.println(a[2][3]);
System.out.println(Arrays.toString(a[0]));
System.out.println(Arrays.toString(a[1]));
System.out.println(Arrays.toString(a[2]));
}
}
【示例】获取数组长度
//获取的二维数组第一维数组的长度。
System.out.println(a.length);
//获取第二维第一个数组长度。
System.out.println(a[0].length);
3.2 数组存储表格数据
【示例】使用二维数组保存表格
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
Object[] emp0 = {1001,"张三","程序员","2020-2-2"};
Object[] emp1 = {1002,"李四","程序员","2020-3-2"};
Object[] emp2 = {1003,"王五","程序员","2020-4-2"};
Object[][] emps = new Object[3][];
emps[0] = emp0;
emps[1] = emp1;
emps[2] = emp2;
//打印二维数组
for (int i = 0; i < emps.length; i++) {
System.out.println(Arrays.toString(emps[i]));
}
//使用嵌套循环打印
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和一维数组存储表格
/**
* 使用javabean和数组存储表格的信息
*/
public class Test01 {
public static void main(String[] args) {
Emp emp0 = new Emp(1001,"张三",18,"程序员","2020-02-02");
Emp emp1 = new Emp(1002,"李四",20,"程序员","2020-03-02");
Emp emp2 = new Emp(1003,"王五",19,"程序员","2020-04-02");
Emp[] emps = new Emp[3];
emps[0] = emp0;
emps[1] = emp1;
emps[2] = emp2;
for (int i = 0; i < emps.length; i++) {
System.out.println(emps[i]);
}
}
}
class Emp {
private int id;
private String name;
private int age;
private String job;
private String hiredate;
public Emp(int id, String name, int age, String job, String hiredate) {
this.id = id;
this.name = name;
this.age = age;
this.job = job;
this.hiredate = hiredate;
}
@Override
public String toString() {
return getId()+"\t"+getName()+"\t"+getAge()+"\t"+getJob()+"\t"+getHiredate();
}
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 String 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 getHiredate() {
return hiredate;
}
public void setHiredate(String hiredate) {
this.hiredate = hiredate;
}
}
4. 常见算法
理解各种算法：可视化算法网站
4.1 冒泡排序
4.1.1 冒泡排序的基本算法
冒泡排序算法的运作如下：
1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
【示例】冒泡排序的基础算法
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] values = { 3, 1, 6, 2, 9, 0, 7, 4, 5, 8 };
bubbleSort(values);
System.out.println(Arrays.toString(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;
}
}
}
}
}
4.1.2 冒泡排序的优化算法
冒泡排序的算法优化一下，基于冒泡排序的以下特点：
1.整个数列分成两部分：前面是无序数列，后面是有序数列。
2.初始状态下，整个数列都是无序的，有序数列是空。
3.每一趟循环可以让无序数列中最大数排到最后，(也就是说有序数列的元素个数增加1)，也就是不用再去顾及有序序列。
4.每一趟循环都从数列的第一个元素开始进行比较，依次比较相邻的两个元素，比较到无序数列的末尾即可(而不是数列的末尾);如果前一个大于后一个，交换。
5.判断每一趟是否发生了数组元素的交换，如果没有发生，则说明此时数组已经有序，无需再进行后续趟数的比较了。此时可以中止比较。
【示例】冒泡排序的优化算法
import java.util.Arrays;
public class Test1 {
public static void main(String[] args) {
int[] values = { 3, 1, 6, 2, 9, 0, 7, 4, 5, 8 };
bubbleSort(values);
System.out.println(Arrays.toString(values));
}
public static void bubbleSort(int[] values) {
int temp;
int i;
// 外层循环：n个元素排序，则至多需要n-1趟循环
for (i = 0; i < values.length - 1; 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;
}
}
}
}
4.2 二分法查找
二分法检索(binary search)又称折半检索
二分法检索的基本思想：
- 数组中的元素从小到大有序地存放在数组(array)中，
- 将给定值key与数组中间位置上元素的关键码(key)比较，
- 如果相等，则检索成功;
若key小，则在数组前半部分中继续进行二分法检索；
若key大，则在数组后半部分中继续进行二分法检索。 - 这样，经过一次比较就缩小一半的检索区间，如此进行下去，直到检索成功或检索失败。
二分法示意图：
【示例】二分法查找
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr = { 30,20,50,10,80,9,7,12,100,40,8};
int searchWord = 20; // 所要查找的数
Arrays.sort(arr); //二分法查找之前，一定要对数组元素排序
System.out.println(Arrays.toString(arr));
System.out.println(searchWord+"元素的索引："+binarySearch(arr,searchWord));
}
public static int binarySearch(int[] array, int value){
int low = 0;
int high = array.length - 1;
while(low <= high){
int middle = (low + high) / 2;
if(value == array[middle]){
return middle; //返回查询到的索引位置
}
if(value > array[middle]){
low = middle + 1;
}
if(value < array[middle]){
high = middle - 1;
}
}
return -1; //上面循环完毕，说明未找到，返回-1
}
}
226
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
