数组
基本介绍
数组可以存放多个同一类型的数据，数组也是一种数据类型，是引用类型。
即：数组就是一组数据。
数组的使用
1、数组的定义
方法一：
数据类型[] 数组名 = new 数据类型[大小]
说明：int[] a = new int[5]; //创建一个数组，名字a，存放5个int。
单独声明： new[]{1,2,3,4};
方法二：
int[] a; //先声明
a = new int[5]; // 再new
方法三 静态初始化：
数据类型 数组名[] = {元素值，元素值...}
int[] a = {2,3,4,5,6,7}
声明空数组: new int[0]
2、数组的引用
数组名[下标/索引]
注意细节
1、数组是多个相同数据类型的组合，实现对这些数据的同意管理。【或者满足自动转换】
double[] array1 = {1.1, 2.2, 3.3, 4}; // 4可以自动转换为小数。
2、数组中的元素可以是任何数据类型，包括基本类型和引用类型。但是不能混用。
3、数组创建后，如果没有赋值，则有默认值。
int、short、byte、long： 0
boolean： flase
String：null
float、double： 0.0
char：\u0000
4、数组的下标是从 0 开始的。
5、数组的下标必须在范围内调用。否则报：下标越界异常
6、数组是引用类型，数组型数据是对象（object）
数组赋值机制
1、基本数据类型赋值，这个值是具体的数据，而且相互不影响，赋的是值。
2、数组在默认情况下是引用传递，赋的值是地址。
值传递/值拷贝 和 引用传递/地址拷贝 的区别
数据拷贝
public class Array01{
public static void main(String[] args){
int[] arr1 = {10, 20, 30};
// 1、创建一个新的数组arr2，开辟新的空间，大小为arr1.length
int[] arr2 = new int[arr1.length];
for (int i=1; i<arr2.length; i++) {
arr2[i] = arr1[i];
}
arr2[0] = 100;//修改arr2不会对arr1产生影响
for (int i=0; i<arr2.length; i++) {
System.out.println(arr2[i]);
}
}
}
public class Array01{
public static void main(String[] args){
int[] arr1 = {10, 20, 30};
// 1、创建一个新的数组arr2，开辟新的空间，大小为arr1.length
int[] arr2 = new int[arr1.length];
for (int i=0, j=0; i<arr2.length; i++, j++) {
arr2[j] = arr1[i];
}
for (int i=0; i<arr2.length; i++) {
System.out.print(arr2[i] + "\t");
}
}
}
数组反转
public class Array01{
public static void main(String[] args){
int[] arr1 = {11,22,33,44,55,66,77};
int len = arr1.length;
for (int i=0; i <= len/2-1; i++) {
int temp = arr1[i];
arr1[i] = arr1[len-1-i];
arr1[len-1-i] = temp;
}
for (int i=0; i<len; i++) {
System.out.println(arr1[i]);
}
}
}
数组添加
实现动态的给数组添加元素，实现对数组的扩容
1、原始数组使用静态分配： int[] arr = {1,2,3};
2、增加元素，直接放在数组的最后：arr = {1,2,3,4}
3、用户可以通过如下方法来决定是否继续添加。添加成功，是否继续添加? Y\N
import java.util.Scanner;
public class Array01{
public static void main(String[] args){
int[] arr1 = {1,2,3};
while(true){
System.out.println("是否添加？ y/n");
Scanner myScanner = new Scanner(System.in);
char answer = myScanner.next().charAt(0);
if (answer == 'y'){
System.out.println("请输入添加的值");
int addNum = myScanner.nextInt();
// 创建新的数组用于添加元素。
int[] arr2 = new int[arr1.length + 1];
for (int i=0; i < arr1.length; i++) {
arr2[i] = arr1[i];
}
arr2[arr2.length-1] = addNum;
arr1 = arr2;
System.out.println("数据添加成功");
for(int i=0; i<arr1.length; i++){
System.out.print(arr1[i] + "\t");
}
} else{
break;
}
}
}
}
排序
排序是将一组数据，按照指定的顺序进行排列的过程。【之后详细介绍】
排序的分类：
1、内部排序
指将需要处理的所有数据都加载到内部存储器中进行排序，包括（交换式排序法，选择式排序法和插入式排序法）
2、外部排序法
数据量过大，无法全部加在到内存中，需要借助外部存储进行排序。包括（合并排序法和直接合并排序法）
冒泡排序：
冒泡排序的特点：
方法一：
public class Array01{
public static void main(String[] args){
int[] arr1 = {1,8,7,4,6,5};
for (int i=0; i<(arr1.length-1); i++) {
for (int z = i; z<arr1.length; z++) {
if (arr1[i] > arr1[z]){
int temp = arr1[z];
arr1[z] = arr1[i];
arr1[i] = temp;
}
}
}
for (int i=0; i<arr1.length; i++) {
System.out.println(arr1[i]);
}
}
}
方法二
public class Array01{
public static void main(String[] args){
int[] arr1 = {1,8,7,4,3,5};
for (int x=0; x<arr1.length-1; x++) {
for (int i=0; i<arr1.length-1-x; i++) {
if (arr1[i] > arr1[i+1]){
int temp = arr1[i+1];
arr1[i+1] = arr1[i];
arr1[i] = temp;
}
}
for (int z=0; z<arr1.length; z++) {
System.out.print(arr1[z] + "\t");
}
System.out.println();
}
}
}
查找
1、顺序查找
2、二分查找【算法中详细介绍】
多维数组
public class Array01{
public static void main(String[] args){
/*
请用二维数组输出如下图形：
0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0 0
*/
int[][] array1 = {{0, 0, 0, 0, 0, 0},
{0, 0, 1, 0, 0, 0},
{0, 2, 0, 3, 0, 0},
{0, 0, 0, 0, 0, 0}};
for (int i=0; i < array1.length; i++) {
for (int z=0; z < array1[i].length; z++) {
System.out.print(array1[i][z] + " ");
}
System.out.println();
}
}
}
二维数组的使用
1、动态初始化
-
语法： 类型[][] 数组名 = new 类型[大小][大小];
-
比如：int a[][] = new int[2][3];
二维数组在内存中的表现形式：
注意：在第一层保存的是地址，第二层才是数据。发散思维，想想三维四维数组。
2、动态初始化
-
先声明： 类型[][] 数组名;
-
再定义（开辟空间） 数组名 = new 类型[大小][大小]
-
比如：
int[][] array01; array01 = new int[2][3];
```Java
public class Array01{
public static void main(String[] args){
/* 方法一 */
// int[][] array01; // 先声明
// array01 = new int[2][3];
/* 方法二 */
int[][] array01 = new int[2][3];
// 输出二维数组中的元素
for (int i=0; i<array01.length; i++) {
for (int j=0; j<array01[i].length; j++) {
System.out.print(array01[i][j] + " ");
}
System.out.println();
}
}
}
3、动态初始化 → 列数不确定
public class Array01{
public static void main(String[] args){
// 创建一个二维数组，但只确定一维数组的个数，所以空着。
int[][] arr01 = new int[4][];
// 遍历arr的每个一维数组。
for (int i=0; i<arr01.length; i++) {
// 给每个一维数组开辟空间。
// 如果没有给一维数组new的话，arr[i] 就是null
arr01[i] = new int[i+1];
// 遍历一维数组，并给一维数组的每个元素赋值。
for (int z=0; z<arr01[i].length; z++) {
arr01[i][z] = i+1; //赋值
}
}
for (int i=0; i<arr01.length; i++) {
for (int z=0; z<arr01[i].length; z++) {
System.out.print(arr01[i][z] + "\t");
}
System.out.println();
}
}
}
4、静态初始化
- 定义： 类型[][] 数组名 = {{值1,值2 …},{值1,值2 …},{值1,值2 …},{值1,值2 …}}
int[][] arr = {{1,1,1},{2,2,2},{3}};
二维数组使用细节和注意事项
1、一维数组的声明方式有：
int[] arr01 = new int[2]; 或者 int arr01[] = new int[2];
int[] arr01 = new int[]{1,2}
2、二维数组的声明方式有：
int[][] arr01 = new int[2][3];
或者 int arr01[][] = new int[2][3];
int[] arr01[] = new int[2][3];
3、二维数组世纪上是由多个一维数组组成的，它的一维数组的长度可以相同，也可以不同。
比如： int[][] map = {{1,2}{3,3,4}};
这种不相同长度的，我们称为：列数不等 的二维数组。
测试题
1、判断
int[] x,y[]; //声明x为int类型的一维数组，y为int类型的二维数组
总结：关键是类型的对应，即int对应int，int[] 对应 int[]
2、BD
3、 已知有个升序的数组，要求插入一个元素，该数组的顺序仍然是升序。
比如：{10,12,40, 90} 添加43后，数组为{10,12,40,43,90}
public class Array01{
public static void main(String[] args){
int[] arr01 = {10, 12, 40, 90};
int intsertIndex = -1;
int value = 42;
int[] arrNew = new int[arr01.length+1];
for (int i=0; i<arr01.length; i++) {
if(arr01[i] > value){
intsertIndex = i;
break;
}
}
if (intsertIndex == -1){
intsertIndex = arr01.length;
}
System.out.println("插入数据的位置为:" + intsertIndex);
for (int i=0, j=0; i<arrNew.length; i++) {
if (i != intsertIndex){
arrNew[i] = arr01[j];
j++;
} else{
arrNew[i] = value;
}
}
System.out.println("数据插入成功，输出扩容后的数据");
arr01 = arrNew;
for (int i=0; i< arr01.length; i++) {
System.out.print(arr01[i] + "\t");
}
System.out.println();
}
}
扫一扫
2669
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
