数组
数组的定义
数组是相同类型数据的有序集合
数组的声明创建
- 必须先声明数组变量，才可以在程序中使用数组
int[] array; //首选的方法
int array[];
- java语言中使用new操作符来创建数组
int[] array = new int[10];
- 数组的元素是通过索引访问的，数组索引从0开始。：array[0]
- 获取数组长度 ：arrays.length
例:
public class ArrayDemo01 {
public static void main(String[] args) {
int[] nums; //1、声明一个数组
nums = new int [10]; //2、创建一个数组
int sum = 0;
//3、给数组赋值
for (int i = 0; i <nums.length ; i++) {
nums[i]= (i+1);
}
//4、计算所有元素的和
for (int i = 0; i <nums.length ; i++) {
System.out.print(nums[i]+" ");
}
System.out.println();
//5、获取数组长度 array.length
for (int i = 0; i <nums.length ; i++) {
sum = sum + nums[i];
}
System.out.println("和为 "+sum);
}
}
//执行结果
1 2 3 4 5 6 7 8 9 10
和为 55
Java 的 for each 循环
Java可以用一个功能来依次处理数组中的每个元素（其他类型的元素集合亦可）而不必为指定下标值分心。
这种增强的for循环格式为：
for (变量类型 新变量名:数组名)
System.out.println(新变量名);
int[] a = {1, 3, 8};
for (int element: a)
System.out.println(element);
//执行结果
1
3
8
打印数组 a 的每一个元素，一个元素占一行。
(优势)这个循环应该被读作“循环a中的每一个元素”(for each element in a)。当然，传统的for循环也可以获得的同样的效果，但是需要花费精力去关心下标的起始值和终止值。
去关心下标的起始值和终止值。
内存分析
三种初始化
- 静态初始化
int [] a = {1,2,3,4,5,6};
- 动态初始化
int [] b = new int[10];
b[0]=1;
b[1]=2;
- 数组的默认初始化
数组为引用类型，元素相当于类的实例变量，因此数组如果被分配了空间，其中的每个元素也被按照实力变量同样的方式被隐式初始化。
数组的四个基本特点
- 其长度是确定的。数组一旦被创建，大小不能改变。
- 其元素必须是相同类型
- 数组中的元素可以是任何的类型，包括引用类型和基本类型
- 数组变量为引用类型，可以看其为对象。数组中元素看其为对象的成员变量。数组本身就是对象，Java中对象在堆中，故数组无论是原始类型还是其他对象类型，数组对象本身都在堆中。
数组边界
- 下标的合法区间：[0,lenght-1]
- 数组就是相同类型的有序集合
- 数组也是对象，数组元素相当于对象的成员变量
- 数组长度的确定，不可变的，如果越界，报错：java.lang.ArrayIndexOutOfBoundsException: 数组越界错误
数组的使用
public class ArrayDemo04 {
public static void main(String[] args) {
int[] nums = {1,2,3,4,5,6,7,8,9,10};
//用for-each 增强型循环遍历数组，但是不可以操控下标值
for (int num : nums) {
System.out.print(num+" ");
}
System.out.println();
System.out.println("=======================================");
int[] fan = resever(nums);
print(nums);
System.out.println();
print(fan);
}
//反转数组
public static int[] resever(int[] arrays){
int[] result = new int[arrays.length];
for (int i = 0,j=result.length-1; i <arrays.length ; i++,j--) {
result[j] = arrays[i];
}
return result;
}
//输出数组方法
public static void print(int[] arrays){
for (int i = 0; i <arrays.length ; i++) {
System.out.print(arrays[i]+" ");
}
}
}
//执行结果
1 2 3 4 5 6 7 8 9 10
=======================================
1 2 3 4 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
多维数组
多维数组可以看成是数组的数组。比如二维数组可以看成是特殊的一维数组。每个元素就是一个一维数组。
二维数组
int a[][] = new int[2][5];
练习：
public class ArrayDemo05 {
public static void main(String[] args) {
//定义二维数组
int[][] a = {{1,3,4},{2,7,6},{7,5,3},{8,5,3}};
//遍历二维数组
for (int i = 0; i <a.length ; i++) {
for (int j = 0; j <a[0].length ; j++) {
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}
Arrays类
-
数组的工具类 ava.util.Arrays;
-
对数据对象进行基本操作
-
查看JDK帮助文档
-
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以使用类名进行调用，不用使用对象来调用（是不用不是不能）
-
常用功能
- 给数组赋值： 通过fill方法
- 给数组排序： 通过sort方法，按升序
- 比较数组：通过equals方法比较数组中元素是否相等。
- 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
练习：
public class ArrayDemo06 {
public static void main(String[] args) {
int[] a = {1,3,42,7,7,5,38,5,3};
//遍历数组
System.out.println(Arrays.toString(a));
//排序，升序
Arrays.sort(a);
System.out.println(Arrays.toString(a));
//给数组赋值
Arrays.fill(a,2,7,22);//第2到第7之间元素被22填充
System.out.println(Arrays.toString(a));
}
}
冒泡排序
外层循环：决定排序趟数
内层循环：决定该趟的比较次数。
练习：
package com.array;
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] arrays = {3, 2, 5, 89, 8, 4, 10, 32, 167};
sort(arrays);
System.out.println(Arrays.toString(arrays));
}
public static void sort(int[] array) {
int max = array[0];
int t = 0;
//外层循环决定排序多少趟。
for (int i = 0; i < array.length - 1; i++) {
boolean flag = false;
//内层循环决定每趟比较多少次
for (int j = 0; j < array.length - 1-i; j++) {
if (array[j] < array[j + 1]) {
t = array[j];
array[j] = array[j + 1];
array[j + 1] = t;
flag = true;
}
if (flag == false ){
break;
}
}
}
}
}
//执行结果
[167, 89, 32, 10, 8, 5, 4, 3, 2]
稀疏数组
稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是值无效数据量远大于有效数据量的数组
例：
package com.array;
import java.util.Arrays;
public class ArrayDemo08 {
public static void main(String[] args) {
//定义初始数组
int[][] begin = new int[10][10];
begin[2][3] = 1;
begin[3][4] = 2;
begin[4][5] = 3;
//输出初始数组
System.out.println("起始数组：");
for (int i = 0; i <begin.length ; i++) {
for (int j = 0; j <begin[0].length ; j++) {
System.out.print(begin[i][j]+"\t");
}
System.out.println();
}
System.out.println("=============================");
//*****转换成稀疏数组
//1、先获取有效值
int sum=0;
for (int i = 0; i <begin.length ; i++) {
for (int j = 0; j <begin[0].length ; j++) {
if (begin[i][j]!=0){
sum++;
}
}
}
//2、创建稀疏数组。
int[][] over = new int[sum+1][3];
over[0][0]=10;
over[0][1]=10;
over[0][2]=sum;
//3、赋值
int count = 0;
for (int i = 0; i <begin.length ; i++) {
for (int j = 0; j <begin[0].length ; j++) {
if (begin[i][j]!=0){
count++;
over[count][0]=i;
over[count][1]=j;
over[count][2]=begin[i][j];
}
}
}
//输出稀疏数组
System.out.println("输出稀疏数组：");
for (int i = 0; i <over.length ; i++) {
for (int j = 0; j <over[0].length ; j++) {
System.out.print(over[i][j]+"\t");
}
System.out.println();
}
System.out.println("=============================");
//返回原数组
//创建一个数组；
int[][] array = new int[over[0][0]][over[0][1]];
//赋值
for (int i = 1; i <over.length ; i++) {
array[over[i][0]][over[i][1]]=over[i][2];
}
//输出数组
System.out.println("输出还原的数组：");
for (int i = 0; i <array.length ; i++) {
for (int j = 0; j <array[0].length ; j++) {
System.out.print(array[i][j]+"\t");
}
System.out.println();
}
}
}
//执行结果
起始数组：
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 0 0 2 0 0 0 0 0
0 0 0 0 0 3 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
=============================
输出稀疏数组：
10 10 3
2 3 1
3 4 2
4 5 3
=============================
输出还原的数组：
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 0 0 2 0 0 0 0 0
0 0 0 0 0 3 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
2793
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
