1 数组的定义
2 数组的声明和创建
package com.joy.array;
public class ArrayDemo01 {
//变量类型 变量名 = 变量值;
//数组类型
public static void main(String[] args) {
int[] nums; //1.声明一个数组 (首选)
int nums2[]; // 效果相同(非首选)
nums = new int[10]; //2.创建一个数组 这里面可以存放10个int类型的数字
int[] nums3 = new int[10]; //合并1和2步
//3.给数组元素赋值
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[7] = 8;
nums[8] = 9;
nums[9] = 10;
//计算所有元素的和
int sum = 0;
//获取数组长度 arrays.length
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
System.out.println("总和为:"+sum);
}
}
3 三种初始化及内存分析
3.1 内存分析
- 第一步在栈中出现array
- 第二步在堆中出现1个空的数组,其中包含10个空位
- 第三步10个值被填入
- 如果代码输出nums[11],报错,数组下标越界
3.2 三种初始化
package com.joy.array;
public class ArrayDemo02 {
public static void main(String[] args) {
//静态初始化:创建 + 赋值
int[] a = {1,2,5,7,8,32};
System.out.println(a[4]); //8
//动态初始化:包含默认初始化(即未被赋值的为默认值,int默认0,string默认空)
int[] b = new int[10];
b[0] = 10;
System.out.println(b[0]); //10
System.out.println(b[1]); //0
System.out.println(b[2]); //0
System.out.println(b[3]); //0
}
}
4 数组的四个基本特点
5 数组边界
6 数组的使用
6.1 普通的for循环
package com.joy.array;
public class ArrayDemo03 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//打印全部数组元素
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
System.out.println("=====================");
//计算所有元素的和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum += arrays[i];
}
System.out.println("sum"+sum);
System.out.println("=====================");
//查找最大元素
int max = arrays[0];
for (int i = 1; i < arrays.length; i++) {
if (arrays[i]>max){
max = arrays[i];
}
}
System.out.println("max="+max);
}
}
6.2 For-Each循环
package com.joy.array;
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//arrays.for回车 自动生成
//JDK1.5以上,没有下标,适用于遍历,但不能操作每个元素
for (int array : arrays) {
System.out.println(array);
}
}
}
6.3 数组作方法入参
package com.joy.array;
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
printArray(arrays); //1 2 3 4 5
}
//打印数组元素
public static void printArray(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
}
6.4 数组作返回值
package com.joy.array;
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
int[] reverse = reverse(arrays);
printArray(reverse);
}
//打印数组元素
public static void printArray(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
//反转数组
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
//反转的操作
for (int i = 0,j = arrays.length-1; i < arrays.length; i++,j--) {
result[j] = arrays[i];
}
return result;
}
}
7 多维数组
- 二维数组 (两行两列)
- 二维:平面直角坐标系第一象限
- 三维:空间直角坐标系(int[][][])
package com.joy.array;
public class ArrayDemo05 {
public static void main(String[] args) {
//int[4][2] 四行两列
/*
1,2 array[0]
2,3 array[1]
3,4 array[2]
4,5 array[3]
*/
int[][] array = {{1,2},{2,3},{3,4},{4,5}};
printArray(array[0]); // 1 2
System.out.println(array[0][1]); //2
System.out.println(array.length); //4 输出最外部长度
System.out.println(array[0].length); //2
//System.out.println(array[0]); 直接输出不了 因为array[0]也是数组(对象)
//遍历二维数组
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}
//打印数组元素
public static void printArray(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
}
8 Arrays类
package com.joy.array;
import java.util.Arrays;
public class ArrayDemo06 {
public static void main(String[] args) {
int[] a = {1,35,18,67,1324,3,54,23,54,99};
System.out.println(a); //[I@29453f44
printArray(a); //[1, 35, 18, 67, 1324, 3, 54, 23, 54, 99]
Arrays.sort(a); //数组排序:升序
//打印数组元素Array.toString
System.out.println(Arrays.toString(a)); //[1, 3, 18, 23, 35, 54, 54, 67, 99, 1324]
Arrays.fill(a,2,4,0); //数组填充 左闭右开区间 只有a[2]和a[3]被填充为0
System.out.println(Arrays.toString(a)); //[1, 3, 0, 0, 35, 54, 54, 67, 99, 1324]
}
//不建议重复造轮子
public static void printArray(int[] a){
for (int i = 0; i < a.length; i++) {
if (i==0){
System.out.print("[");
}
if (i==a.length-1){
System.out.print(a[i]+"]");
}else{
System.out.print(a[i] + ", ");
}
}
System.out.println();
}
}
9 冒泡排序
- 从后到前两两挨个比较大小,第一轮能够把min放到最前,第二轮能够把第二小的放到第二个……
package com.joy.array;
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a = {1,345,31,59,83,90,32};
int[] sort = sort(a); //调用完写好的冒泡排序,返回一个排序后的数组
System.out.println(Arrays.toString(sort));
}
//冒泡排序 (降序)
//1.比较数组中,两个相邻的元素,如果第一个数比第二个数小,交换它们的位置
//2.每次比较,都会产生一个最大和一个最小数
//3.下一轮则可以少一次排序!
//4.依次循环直到结束
public static int[] sort(int[] array){
//临时变量
int temp = 0;
//外层循环:判断要走多少次 (一共要比较的轮数)
for (int i = 0; i < array.length-1; i++) {
boolean flag = false; //通过flag标识位减少没有意义的比较
//内层循环:比较两个数大小,如果第一个数比第二个数大,则交换位置 (数与数需要比较的次数)
for (int j = 0; j < array.length-1-i; j++) {
if (array[j+1]>array[j]){ //升序 array[j+1]<array[j]
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true; //如果本身满足array[j+1]>array[j],flag==false
}
}
if (flag==false){
break; //如果break说明排序正确,不需要继续排序,跳出循环
}
}
return array;
}
}
10 稀疏数组
10.1 稀疏数组介绍
package com.joy.array;
public class ArrayDemo08 {
public static void main(String[] args) {
//1.创建一个二维数组 11*11 0:没有棋子 1:黑棋 2:白棋
int[][] array1 =new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始数组
System.out.println("输出原始数组:");
//array1.for回车 遍历
for (int[] ints : array1) {
//ints.for回车
for (int anInt : ints) {
System.out.print(anInt+"\t"); // "\t"产生空格
}
System.out.println();
}
System.out.println("======================================");
//转换为稀疏数组保存
//1.获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j]!=0){
sum++;
}
}
}
System.out.println("有效值个数:" + sum);
//2.创建一个稀疏数组的数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//3.遍历二维数组,将非0的值存放在稀疏数组中
int count = 0;
for (int i = 0; i < array1.length; i++) { //二维数组的行数
for (int j = 0; j < array1[i].length; j++) { //二维数组的列数
if (array1[i][j]!=0){
count++; //给非0的值计数
array2[count][0] = i; //横坐标
array2[count][1] = j; //纵坐标
array2[count][2] = array1[i][j]; //值
}
}
}
//输出稀疏数组
System.out.println("稀疏数组:");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0]+"\t"
+array2[i][1]+"\t"
+array2[i][2]+"\t");
}
System.out.println("======================================");
//还原
System.out.println("还原");
//1.读取稀疏数组的值
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.给其中的元素还原它的值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//3.打印
//输出原始数组
System.out.println("输出还原数组:");
//array1.for回车 遍历
for (int[] ints : array1) {
//ints.for回车
for (int anInt : ints) {
System.out.print(anInt+"\t"); // "\t"产生空格
}
System.out.println();
}
}
}