Java数组
数组
- 定义：
- 数组是相同类型数据的有序集合
- 数组描述是若干个同类型的有先后次序的数据，每个元素可以通过下标访问
- 数组的下标是从0开始的
数组声明创建
- 首先必须声明数组变量才能使用
dataType[] array;
dataType array[];
- Java 语言使用new来创建数组
- 数组元素通过索引访问，从0开始
- 获取数组长度：array.length，数组长度一经确定不可改变
public class Demon01 {
public static void main(String[] args) {
//数组类型
int[] numbers; // 只是定义
int nums[]; // C风格数组
nums = new int[10]; // nums可以存放10个整型数字
nums[0] = 1;
nums[1] = 2;
System.out.println(nums[8]);
int sum = 0;
for(int i=0;i<nums.length;i++){
sum += nums[i];
}
}
}
- 内存分析
- Java内存分为堆、栈、方法区
- 堆：
- 栈：
- 方法区：
1. 声明数组：int[] nums;
在栈中创建一个变量,声明式数组并不存在
2. 创建数组：nums = new int[10];
在堆中分配一片空间，此时物理上数组才真的存在
3. 给数组元素赋值
- 三种初始化：
public class Demon02 {
public static void main(String[] args) {
//静态初始化
int[] num1 = {1, 2, 3, 4, 5};
//动态初始化
int[] b = new int[10];
//包含默认初始化，即全是0
//数组一经分配空间就都有默认值的。
}
}
- 数组的四个基本特点
- 长度确定，一旦被创建大小就不能改变
- 元素必须是相同类型，不允许出现不同类型
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型
- 数组变量属于引用类型，数组本身就是对象，对象在堆中
数组使用
- for-each循环
- 数组作为方法入参
- 数组作返回值
public class Demon03 {
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]);
}
//求和
int sum = 0;
for(int i=0; i<arrays.length; i++){
sum += arrays[i];
}
System.out.println(sum);
//查找最大元素
int max = arrays[0];
for(int i=1; i<arrays.length; i++){
if(max<arrays[i]){
max = arrays[i];
}
}
//for_each循环
for (int array : arrays) {
System.out.println(array);
}
}
//打印数组元素
public static void print(int[] arrays){
for(int i=0; i<arrays.length; i++){
System.out.println(arrays[i]);
}
}
//反转数组
public static int[] reverse(int[] arrays){
int[] rev = new int[arrays.length];
for(int i=0; i<arrays.length; i++){
rev[arrays.length-i-1] = arrays[0];
}
return rev;
}
}
多维数组
- 多维数组可以看成数组的数组
- 二维数组：
int[][] array = new int[10][10];
public class Demon04 {
public static void main(String[] args) {
// 4x2的数组
int[][] arrays = {{1,2},{2,3},{3,4},{4,5}};
System.out.println(arrays[0][0]);
for (int i=0; i<arrays.length; i++){
for(int j=0; j<arrays[i].length; j++){
System.out.println(arrays[i][j]);
}
}
}
}
Arrays 类
- 数组工具类：java.util.arrays
- 工具类中提供了一个Arrays供我们使用，可以堆数组对象进行一些基本操作
- 因为都为static修饰的静态方法，所以不用使用对象来调用
- 通常有以下功能：
- 数组全部赋某个值：fill
- 数组排序：sort，升序
- 比较数组：equals比较数组
- 查找数组：binarySearch方法可以二分查找
import java.util.Arrays;
public class Demon05 {
public static void main(String[] args) {
int[] arrays = {1,2,3,45,6,890};
System.out.println(arrays);
System.out.println(Arrays.toString(arrays));
Arrays.fill(arrays, 0);
}
public static void printArray(int[] arrays){
System.out.print("[");
for(int i=0; i<arrays.length;i++){
if(i!=arrays.length-1){
System.out.print(arrays[i]+", ");
}else{
System.out.println(arrays[i] + "]");
}
}
}
}
冒泡排序
- 总共有八大排序算法
- 冒泡排序的思路是简单的，即从数组一端开始每次交换相邻大小相反了的元素直至另外一段，就能得到一个最大值。
- 要点在于：冒泡的泡每次都必须从底端开始冒，冒到之前已经排过序的位置为止。
import java.util.Arrays;
public class Demon06 {
public static void main(String[] args) {
int[] arrays = {12, 1, 34, 23, 5};
int[] sort = sort(arrays);
System.out.println(Arrays.toString(arrays));
}
//比较数组中相邻的元素，进行排序
//每次就能得到一个最大或最小的排序
public static int[] sort(int[] arrays){
int temp = 0;
for(int i=0; i< arrays.length-1; i++){
for(int j= arrays.length-1; j>i; j--){
if(arrays[j]>arrays[j-1]){
temp = arrays[j];
arrays[j] = arrays[j-1];
arrays[j-1] = temp;
}
}
}
System.out.println(Arrays.toString(arrays));
return arrays;
}
}
稀疏数组
- 需求：编写五子棋的游戏，存盘的功能
- 分析：因为二维数组许多值是零，因此记录了许多无用信息。
- 稀疏数组：大部分元素是0或者是相同的元素，可以使用稀疏数组。
- 处理方式：记录数组共几行几列，有多少个不同值，把不同值的元素和行列记录在一个小规模的数组里，压缩数组的规模
public class Demon07 {
public static void main(String[] args) {
//创建二维数组，0代表没下，1代表下了
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 1;
for(int i=0; i<array1.length; i++){
for(int j=0; j<array1[i].length; j++){
System.out.print(array1[i][j]+"\t");
}
System.out.println();
}
//转换稀疏数组
//获取有效值的个数
int sum = 0;
for(int i=0; i<array1.length; i++){
for(int j=0; j<array1[i].length; j++){
if(array1[i][j]!=0){
sum++;
}
}
}
//创建稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
int count = 1;
for(int i=0; i<array1.length; i++){
for(int j=0; j<array1[i].length; j++){
if(array1[i][j]!=0){
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
count++;
}
}
}
for(int i=0; i<array2.length; i++){
for(int j=0; j<array2[i].length; j++){
System.out.print(array2[i][j]+ "\t");
}
System.out.println();
}
//还原数组
System.out.println("**********************");
int temp = 1;
int[][] array3 = new int[array2[0][0]][array2[0][1]];
for(int i=1; i<array2[0][2]; i++){
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
for(int i=0; i<array3.length; i++){
for(int j=0; j<array3[i].length; j++){
System.out.print(array3[i][j]+ "\t");
}
System.out.println();
}
}
}
浙公网安备 33010602011771号