1.动态初始化
//dataType arrayName[] = new dataType[arraySize];
int a[] = new int[5];
//Declare an array variable
//dataType arrayName[];
int a[];
// dataType[] arrayName;
int[] a;
//Creates an integer array of size 5
a = new int[5];
————————————————————————————————————
在Java中，数组的声明有两种语法形式：int[] a1; 和 int a1[];，它们在功能上是完全等价的，但是int[] a1; 更受推荐的原因主要有以下几点：
-
清晰性和一致性：
- 使用
int[] a1;语法更符合 Java 的类型声明习惯。在 Java 中，类型名后紧跟数组标识符[]可以清晰地表达出变量是一个数组。 int a1[];的语法可能会给读者造成困惑，因为它在类型名后和变量名前都有[]，这与 Java 中通常的类型声明方式不一致。
- 使用
-
推荐的数组声明方式：
- Java 编码规范和大多数风格指南都推荐使用
int[] a1;的形式来声明数组。这样做有助于提高代码的可读性和可维护性。 - 在团队中，统一采用
int[] a1;的声明风格可以减少代码审查时的歧义和误解。
- Java 编码规范和大多数风格指南都推荐使用
-
类型推断和泛型化：
- 当数组类型需要使用泛型或者类型推断时，使用
int[] a1;的形式更为自然和直接。 - 例如，
List<int[]> list指的是一个List，其中的元素类型是int[]，这种语法更符合 Java 中泛型的使用方式。
- 当数组类型需要使用泛型或者类型推断时，使用
总之，虽然 int[] a1; 和 int a1[]; 是等效的，但是 int[] a1; 更符合 Java 编程的习惯和规范，使代码更易读、易懂，并且有助于保持一致的编程风格。
2.静态初始化
//dataType arrayName[] = {value1, value2, ..., valueN};
int a[] = {1, 2, ..., n};
//int a[] = new int[10];
int a[];
int num = 10;
a = new int[num];
for (int i = 0; i < num; i++){
a[i] = i * 2 + 1;
}
for (int i = 0; i < num; i++){
System.out.println(a[i]);
}
————————————————————————————————————
细节
int array1[];
array1 = new int[10];
char temp = 'A';
char temp = 97;
array1[0] = temp;
System.out.println(array1[0]);
遍历找最大值：假设第一个元素最大
在Java中，如果你创建了一个数组但没有显式地初始化或赋值给数组元素，Java会根据数组的类型给出默认初始值。这些默认值取决于数组元素的类型：
-
基本类型数组：
byte,short,int,long：默认值为0float,double：默认值为0.0boolean：默认值为falsechar：默认值为\u0000，即空字符
//\u 是一个转义序列，用于表示Unicode字符。
在字符串中，\u 后面跟着四位十六进制数，表示一个Unicode字符的编码值。
-
引用类型数组：
- 默认值为
null
- 默认值为
例如，如果你声明了一个整数数组 int[] arr = new int[5];，而没有显式给数组元素赋值，那么数组 arr 中的每个元素都会被初始化为整数类型的默认值 0。
int[] arr = new int[5];
System.out.println(arr[0]); // 输出 0
对于引用类型数组，例如 String[] strs = new String[3];，则每个元素默认是 null。
String[] strs = new String[3];
System.out.println(strs[0]); // 输出 null
这些默认值确保了数组在创建后，即使没有明确赋值，也不会导致未初始化的情况，而是安全地使用了默认值。
在Java中，数组是一种特殊的对象，因此它是引用类型。无论是基本数据类型的数组（如 int[]、double[] 等）还是引用数据类型的数组（如 String[]、Object[] 等），它们在Java中都是对象。
具体来说，数组对象在堆内存中分配空间，而数组变量本身则是引用，它存储的是数组对象在堆内存中的地址。因此，当你声明一个数组变量时，实际上是在声明一个引用变量。例如：
int[] arr; // 声明一个int类型的数组引用变量 arr
String[] strs; // 声明一个String类型的数组引用变量 strs
在上述声明中，arr 和 strs 都是引用类型的变量，它们可以引用（即指向）分配在堆内存中的具体数组对象。
————————————————————————————————————
In Java, creating an array involves a few basic steps depending on whether you know the size of the array beforehand or if you’re initializing it with specific values. Here are the main ways to create an array in Java:
1. Declare an Array Variable
To declare an array variable without initializing it immediately:
// Syntax: dataType[] arrayName;
int[] myArray; // Declares an integer array named myArray
2. Initialize an Array with Specified Size
To initialize an array with a specific size:
// Syntax: dataType[] arrayName = new dataType[arraySize];
int[] myArray = new int[5]; // Creates an integer array of size 5
3. Initialize an Array with Values
To initialize an array with specific values:
Using Array Initializer (when declaring the array):
// Syntax: dataType[] arrayName = {value1, value2, ..., valueN};
int[] myArray = {1, 2, 3, 4, 5}; // Creates and initializes an array with values 1, 2, 3, 4, 5
Using new Operator (separately from declaration):
// Syntax: dataType[] arrayName = new dataType[] {value1, value2, ..., valueN};
int[] myArray;
myArray = new int[] {1, 2, 3, 4, 5}; // Creates and initializes an array with values 1, 2, 3, 4, 5
Important Notes:
-
Array Indexing: In Java, array indexing starts at 0. Therefore, the first element of an array
myArrayis accessed usingmyArray[0], the second withmyArray[1], and so on. -
Array Length: The length of an array can be obtained using the
lengthproperty (myArray.length), which returns the number of elements in the array. -
Array Types: Arrays in Java can hold primitive data types (like
int,double,boolean, etc.) as well as objects (likeString,Object, etc.).
Example:
Here’s a complete example demonstrating array creation and initialization:
public class ArrayExample {
public static void main(String[] args) {
// Declare and initialize an array with specific values
int[] myArray = {10, 20, 30, 40, 50};
// Print each element of the array
for (int i = 0; i < myArray.length; i++) {
System.out.println("Element at index " + i + ": " + myArray[i]);
}
}
}
This example declares an integer array myArray and initializes it with values {10, 20, 30, 40, 50}. It then iterates through the array using a for loop and prints each element along with its index.
Summary:
Creating arrays in Java involves declaring the array variable, optionally initializing it with a specified size or values using either direct initialization or the new operator. Arrays provide a fundamental way to store and manipulate collections of data in Java programming.
————————————————————————————————————————————————————————————————————————
数组赋值机制
值传递
地址传递
————————————————————————————————————
第一段代码分析：
int a1[];
a1 = new int[]{1, 2, 3};
int a2[] = a1;
a2[0] = 100000;
// 输出 a1 数组的内容
for (int i = 0; i < 3; i++) {
System.out.println("a1[" + i + "]=" + a1[i]);
}
// 输出 a2 数组的内容
for (int i = 0; i < 3; i++) {
System.out.println("a2[" + i + "]=" + a2[i]);
}
结果输出：
a1[0]=100000
a1[1]=2
a1[2]=3
a2[0]=100000
a2[1]=2
a2[2]=3
解释：
int a1[];和int a2[] = a1;定义了两个引用a1和a2，它们都指向同一个数组对象{1, 2, 3}。- 当修改
a2[0] = 100000;时，实际上修改的是数组对象中索引为0的元素，这影响了a1和a2引用指向的同一数组。 - 因此，两个循环输出结果都反映了对数组的修改。
第二段代码分析：
int a1[];
a1 = new int[]{1, 2, 3};
int a2[] = a1;
a2 = new int[]{2, 3, 4};
a2[0] = 100000;
// 输出 a1 数组的内容
for (int i = 0; i < 3; i++) {
System.out.println("a1[" + i + "]=" + a1[i]);
}
// 输出 a2 数组的内容
for (int i = 0; i < 3; i++) {
System.out.println("a2[" + i + "]=" + a2[i]);
}
结果输出：
a1[0]=1
a1[1]=2
a1[2]=3
a2[0]=100000
a2[1]=3
a2[2]=4
解释：
- 同样地，
int a1[];和int a2[] = a1;定义了两个引用a1和a2，它们最初都指向同一个数组对象{1, 2, 3}。 - 然后，
a2 = new int[]{2, 3, 4};将a2的引用指向了一个新的数组对象{2, 3, 4}。此时，a1和a2不再指向同一个数组。 - 因此，当修改
a2[0] = 100000;后，只有a2引用指向的数组被修改，a1引用指向的原始数组{1, 2, 3}并未受到影响。 - 循环输出结果反映了这一点，
a1的内容保持不变，而a2的内容发生了变化。
总结：
- 在 Java 中，数组变量是引用类型，赋值操作会影响到原始数组对象或者是新的数组对象，具体取决于赋值操作时的语义和行为。
- 理解数组引用的赋值和传递对于正确操作和预期结果至关重要。
数组元素逆转
int arr[] = {1, 2, 3, 4, 5, 6};
//1.
for (int i = 0; i < arr.length / 2; i++){
int temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
for (int i = 0; i < arr.length; i++){
System.out.println("arr[" + i + "] = " + arr[i]);
}
//2.
int arr1[] = new int[arr.length];
for (int i = 0; i < arr.length; i++){
arr1[i] = arr[i];
}
for (int i = 0, j = arr.length - 1; i < arr.length / 2 ; i++, j--){
arr[i] = arr1[j];
arr[j] = arr1[i];
}
for (int i = 0; i < arr.length; i++){
System.out.println("arr[" + i + "] = " + arr[i]);
}
System.out.println();
for (int i = 0; i < arr1.length; i++){
System.out.println("arr1[" + i + "] = " + arr1[i]);
}
————————————————————————————————————
数组扩容
int[] arr = {1, 2, 3};
for (int i = 0; i < arr.length; i++){
System.out.println("arr[" + i + "]=" + arr[i]);
}
int[] arr1 = {1, 2, 3, 4};
arr = arr1;
for (int i = 0; i < arr.length; i++){
System.out.println("arr[" + i + "]=" + arr[i]);
}
Scanner input = new Scanner(System.in);
System.out.println("please input an number:");
char choice = input.next().charAt(0);
if (choice == 'y'){
int[] arr2 = new int[arr.length + 1];
for (int i = 0; i < arr.length; i++){
arr2[i] = arr[i];
}
arr2[arr.length] = 5;
arr = arr2;
}
for (int i = 0; i < arr.length; i++){
System.out.println("arr[" + i + "]=" + arr[i]);
}
do…while… + break
int a1[] = {1, 2, 3};
Scanner input = new Scanner(System.in);
char choice;
do{
for (int i = 0; i < a1.length; i++){
System.out.println("a1[" + i + "]=" + a1[i]);
}
System.out.println("please make a choice(y/n)");
choice = input.next().charAt(0);
if(choice == 'y')
{
int a2[] = new int[a1.length + 1];
for (int i = 0; i < a1.length; i++){
a2[i] = a1[i];
}
System.out.println("please input an number");
int temp = input.nextInt();
a2[a1.length] = temp;
a1 = a2;
}
}
while(choice != 'n');
数组缩减
int a1[] = {1, 2, 3, 4, 5};
for (int i = 0; i < a1.length; i++){
System.out.println("a1[" + i + "]=" + a1[i]);
}
Scanner input = new Scanner(System.in);
char choice;
do{
System.out.println("continue to delete?(y/n)");
choice = input.next().charAt(0);
if (choice == 'y'){
if (a1.length == 1)
{
System.out.println("CAN NOT CONTINUE TO DELETE!");
break;
}
System.out.println("please input the num");
int delete_num = input.nextInt();
int a2[] = new int[a1.length - 1];
int count = 0;
for (int i = 0; i < a1.length; i++)
{
if (a1[i] == delete_num)continue;
a2[count++] = a1[i];
}
a1 = a2;
}
}
while(choice != 'n');
二维数组内存分布
————————————————————————————————————
二维数组初始化
1. 直接指定数组元素：
int[][] arr = { {1, 2, 3}, {4, 5}, {6} };
- 这种方法适合已知元素数量且结构固定的情况。
- 注意每个子数组的长度可以不同，但要确保每个子数组都被正确初始化。
2. 动态初始化：
int[][] arr = new int[3][2];
- 这里初始化了一个包含3行2列的二维数组。
- 注意内层数组的长度必须在初始化时确定，并且所有元素会被初始化为默认值（例如
0对于int类型）。
3. 分步初始化：
int[][] arr = new int[3][];
arr[0] = new int[] {1};
arr[1] = new int[] {2, 3};
arr[2] = new int[] {4, 5, 6};
- 这种方法允许你为每一行分配不同的列数。
- 注意需要先为外层数组分配空间，然后再为每个内层数组分配空间和赋值。
int[][] arr = new int[3][];
for (int i = 0; i < arr.length; i++){
arr[i] = new int[i + 1];//给一维数组开辟空间
for (int j = 0; j < arr[i].length; j++){
arr[i][j] = i + 1;
}
}
for (int i = 0; i < arr.length; i++){
for (int j = 0; j < arr[i].length; j++){
System.out.println("arr[" + i + "][" + j + "]=" + arr[i][j]);
}
}
注意事项：
-
内层数组长度：在使用动态初始化时，内层数组的长度必须在分配空间时确定。例如，
new int[3][]表示有3行，但每行的列数需要另外确定。 -
数组越界：一定要小心确保访问数组元素时不会越界，特别是在使用循环来访问或修改数组元素时。
-
默认初始化：所有的元素都会根据其类型进行默认初始化，例如
int类型的数组会被初始化为0。 -
数组长度：Java 中二维数组不要求每一行的长度相同，但在访问时必须确保不越界。
-
数组初始化的方式：可以根据具体需求选择合适的初始化方式，灵活使用直接初始化、动态初始化或分步初始化。
通过合理的使用和正确的初始化方式，可以有效避免在数组操作中可能出现的错误和异常。
习题
Scanner input = new Scanner(System.in);
char choice;
int arr[] = {10, 12, 45, 90};
do{
boolean flag = false;
for (int i = 0; i < arr.length; i++){
System.out.println("arr[" + i + "]=" + arr[i]);
}
System.out.println("Add a new num?(y/n)");
choice = input.next().charAt(0);
if (choice == 'y'){
System.out.println("please input the num ");
int num = input.nextInt();
int arr1[] = new int[arr.length + 1];
int index = 0;
for (int i = 0; i < arr1.length; i++){
if (arr[0] >= num && !flag ){
flag = true;
arr1[i] = num;
continue;
}
if (arr[arr.length - 1] <= num && i == arr.length && !flag){
flag = true;
arr1[arr.length] = num;
continue;
}
if ( (i - 1 >= 0 && arr[i - 1] <= num && i <= arr.length - 1 && arr[i] > num) && !flag ){
arr1[i] = num;
flag = true;
continue;
}
arr1[i] = arr[index++];
}
arr = arr1;
}
}
while(choice != 'n');
Scanner input = new Scanner(System.in);
int arr[] = {10, 13, 45, 90};
int num = input.nextInt();
int index = -1;
for (int i = 0; i < arr.length; i++){
if (arr[i] >= num){
index = i;
break;
}
}
if(index == -1)index = arr.length;
int []arr1 = new int[arr.length + 1];
for (int i = 0, j = 0; i < arr.length + 1; i++){
if (i == index){
arr1[i] = num;
continue;
}
arr1[i] = arr[j++];
}
arr = arr1;
for (int i = 0; i < arr.length; i++){
System.out.println("arr[" + i + "]=" + arr[i]);
}
802
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
