java数组
2021-04-06 01:28
标签：java内存分析 元素 result 数据类型 bsp 赋值 lazy 帮助 except 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们 首先必须声明数组变量，才能在程序中使用数组。语法如下： java语言使用new操作符来创建数组，语法如下： 数组的元素是通过索引访问的，数据索引从0开始 获取数组的长度： java内存分析： 画图分析： 静态初始化 动态初始化 数组的默认初始化 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。 其元素必须是相同类型，不允许出现混合类型 数组中的元素可以是任何数据类型，包括基本类型和引用类型。 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的 下标的合法区间：[0，length-1]，如果越界就会报错； ArrayIndexOutOfBoundsException:数组下标越界异常！ 小结： 数组是相同数据类型（数据类型可以为任意类型）的有序集合 数组也是对象。数组元素相当于对象的成员变量 数组长度是确定的，不可变的。如果越界，则报：ArrayIndexOutOfBoundsException For-Each循环 数组作方法入参 数组做返回值 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每个元素都是一个一维数组。 二位数组 可以把上面二维数组a看成一个两行五列的数组。 多维数组的使用 数组的工具类java.util.Arrays 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。 查看JDK帮助文档 Arrays类中的方法都是static修饰的静态方法是，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”） 具有以下常用功能： 给数组赋值：通过fill 方法 对数组排序：通过sort方法，按升序。 比较数组：通过equals方法比较数组中元素值是否相等。 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序！ 冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较。 算法的时间复杂度为O(n²) 如何优化？ 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方式是： 记录数组一共有几行几列，有多少个不同值 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模 如图：左边是原始数组，右边是稀疏数组 需求：编写五子棋游戏中，有存盘退出和续上盘的功能。 分析问题：因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据。 解决：稀疏数组 java数组 标签：java内存分析 元素 result 数据类型 bsp 赋值 lazy 帮助 except 原文地址：https://www.cnblogs.com/DiaoStudy/p/13401288.html1.数组概述
数组的定义
2.数组声明创建
package com.langlang.array;
?
public class ArrayDemo01 {
?
//变量的类型 变量的名字 = 变量的值；
//数组类型
?
public static void main(String[] args) {
//int nums1[];
int[] nums;//声明数组
?
nums = new int[10];//创建数组
?
//赋值
nums[0] = 10;
nums[1] = 14;
nums[2] = 25;
nums[3] = 37;
nums[4] = 92;
nums[5] = 16;
nums[6] = 78;
nums[7] = 98;
nums[8] = 456;
nums[9] = 178;
?
System.out.println(nums[6]); //结果输出 78
?
//计算所有元素的和
int sum = 0;
for (int i = 0;i
内存分析
三种初始化
package com.langlang.array;
?
public class ArrayDemo02 {
public static void main(String[] args) {
?
//静态初始化：创建 + 赋值
int[] a = {1,25,35,78};
System.out.println(a[0]);
?
//动态初始化:包含默认初始化
int[] b = new int[10];
b[0] = 10;
System.out.println(b[0]);
System.out.println(b[2]);
}
}
?数组的四个基本特点
数组边界
3.数组使用
package com.langlang.array;
?
public class ArrayDemo03 {
public static void main(String[] args) {
int[] arrays = {1,2,3,45,6,79,93};
?
//打印全部的数组元素
//普通for循环
for (int i = 0;i
package com.langlang.array;
?
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arrays = {1,2,3,46,5,78,9};
?
//JDK1.5,没有下标
for (int array:arrays) {
System.out.println(array);
}
}
?
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0;i
4.多维数组
package com.langlang.array;
?
public class ArrayDemo05 {
public static void main(String[] args) {
?
//[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}};
?
//打印二维数组
for (int i = 0; i ) {
for (int j = 0; j
5.Arrays类
package com.langlang.array;
?
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
?
import java.util.Arrays;
?
public class ArrayDemo06 {
public static void main(String[] args) {
int[] a = {895,89,875,64,134,9,8794,567,6,345,32,166,46};
?
//打印数组元素Arrays.toString(a)
System.out.println(Arrays.toString(a));
System.out.println("===========");
printArray(a);
System.out.println("=================");
?
//数组进行排序：升序
Arrays.sort(a);
System.out.println(Arrays.toString(a));
System.out.println("=========");
?
//数组填充(全部替换为填充内容)
Arrays.fill(a,0);
System.out.println(Arrays.toString(a));
?
//数组填充（指定位置填充） [2,4) 下标是2的位置开始填充，填充到4（不包括4）
Arrays.fill(a,2,4,555);
System.out.println(Arrays.toString(a));
}
?
public static void printArray(int[] a){
for (int i = 0; i ) {
if (i==0){
System.out.print("[");
}
if (i==a.length-1){
System.out.print(a[i]+"]");
}else{
System.out.print(a[i]+",");
}
}
}
?
}
?
冒泡排序
package com.langlang.array;
?
import java.util.Arrays;
?
public class Arraydemo07 {
public static void main(String[] args) {
?
//冒泡排序
// 1. 比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置
// 2. 每次比较，都会产生一个最大的值，或者最小的值
// 3. 下一轮则可以少一次排序
// 4. 依次循环，直到结束！
?
?
int[] a = {46,7,98,416,81,356,764,82};
?
int[] so = sort(a);
System.out.println(Arrays.toString(so));
}
public static int[] sort(int[] array){
?
//临时变量
int temp = 0;
//外层循环，判断我们这个要走多少次
for (int i = 0; i ) {
?
for (int j = 0; j ) {
if (array[j+1]array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
?
}
return array;
}
}
?6.稀疏数组
稀疏数组介绍
package com.langlang.array;
?
import java.util.Arrays;
?
public class ArrayDemo08 {
public static void main(String[] args) {
?
//创建一个二维数组 11*11 0：没有棋子 1：黑子 2：白子
int[][] a = new int[11][11];
a[1][2] = 1;
a[2][3] = 2;
//输出原始数组
System.out.println("输出原始数组：");
for (int[] ints : a){
for (int anInt : ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
?
//转换为稀疏数组保存
//获取有效值的个数
int sum = 0;
for (int i = 0; i ) {
for (int j = 0; j ) {
?
if (a[i][j]!=0){
sum++;
}
}
}
System.out.println("有效值的个数"+sum);
?
// 2. 创建一个稀疏数组的数组
int[][] array = new int[sum+1][3];
?
array[0][0] =11 ;
array[0][1] =11 ;
array[0][2] =sum ;
?
//稀疏数组的行数
int count = 0;
?
//遍历二维数组，将非零的值，存放稀疏数组中
for (int i = 0; i ) {
for (int j = 0; j ) {
if (a[i][j]!=0){
count++;
array[count][0] = i;
array[count][1] = j;
array[count][2] = a[i][j];
?
}
}
}
?
//输出稀疏数组
System.out.println("稀疏数组：");
?
for (int j = 0; j ) {
System.out.println(
array[j][0]+"\t"
+array[j][1] + "\t"
+array[j][2] + "\t"
);
?
}
?
System.out.println("======================");
System.out.println("还原");
?
// 1. 读取稀疏数组
int[][] array2 = new int[array[0][0]][array[0][1]];
// 2. 给其中的元素还原它的值
for (int i = 1;i