java数组

最新推荐文章于 2022-10-12 16:59:47 发布
最新推荐文章于 2022-10-12 16:59:47 发布
阅读量571 收藏
点赞数 1
分类专栏： 数据库 计算机网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45722156/article/details/109134461
版权

0.方法

在前面几个章节中我们经常使用到 System.out.println()，那么它是什么呢？

  • println() 是一个方法。
  • System 是系统类。
  • out 是标准输出对象。

这句话的用法是调用系统类 System 中的标准输出对象 out 中的方法 println()。

0.1那么什么是方法呢？

Java方法是语句的集合，它们在一起执行一个功能。

  • 方法是解决一类问题的步骤的有序组合
  • 方法包含于类或对象中
  • 方法在程序中被创建，在其他地方被引用

0.2方法的优点

    1. 使程序变得更简短而清晰。
    1. 有利于程序维护。
    1. 可以提高程序开发的效率。
    1. 提高了代码的重用性。

0.3方法的定义

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}
  • **修饰符：**修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
  • 返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
  • **方法名：**是方法的实际名称。方法名和参数表共同构成方法签名。
  • **参数类型：**参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
  • **方法体：**方法体包含具体的语句，定义该方法的功能。
0.3.1实例

下面的方法包含 2 个参数 num1 和 num2，它返回这两个参数的最大值。

/** 返回两个整型变量数据的较大值 */
public static int max(int num1, int num2) {   	
	int result;   
	if (num1 > num2){      
		result = num1;
    }else      
		result = num2;    
		return result;  
	}
}	
/** 主方法 */
   public static void main(String[] args) {
      int i = 5;
      int j = 2;
      int k = max(i, j);
      System.out.println( i + " 和 " + j + " 比较，最大值是：" + k);
   }

更简略的写法（三元运算符）：

public static int max(int num1, int num2) {  
	return num1 > num2 ? num1 : num2;
}

0.4方法调用

Java 支持两种调用方法的方式，根据方法是否返回值来选择

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int larger = max(30, 40);

如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。下面的调用是个语句：

System.out.println("欢迎访问菜鸟教程！");
0.4.1 void 关键字

看例子：

public class TestVoidMethod {
  public static void main(String[] args) {
    printGrade(78.5);
  }
 
  public static void printGrade(double score) {
    if (score >= 90.0) {
       System.out.println('A');
    }
    else if (score >= 80.0) {
       System.out.println('B');
    }
    else if (score >= 70.0) {
       System.out.println('C');
    }
    else if (score >= 60.0) {
       System.out.println('D');
    }
    else {
       System.out.println('F');
    }
  }
}

运行结果

C

这里printGrade方法是一个void类型方法，它不返回值。

一个void方法的调用一定是一个语句。 所以，它被在main方法第三行以语句形式调用。就像任何以分号结束的语句一样。

0.4.2 static

静态（static）

被static修饰，全局唯⼀，类加载，就加载，只加载⼀次

静态⽅法只能调⽤静态⽅法

静态⽅法只能访问静态修饰的常量，变量

静态内部类只能使⽤外部类的静态常量，变量和⽅法

静态方法：

当static修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要

创建类的对象。调用方式非常简单。

静态方法调用的注意事项：

  • 静态方法可以直接访问类变量和静态方法。
  • 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
  • 静态方法中，不能使用this关键字。
  • 小贴士：静态方法只能访问静态成员。

0.5通过值传递参数

下面的例子演示按值传递的效果。

该程序创建一个方法，该方法用于交换两个变量。

public class TestPassByValue {
        public static void main(String[] args) {
            int num1 = 1;
            int num2 = 2;

            System.out.println("交换前 num1 的值为：" +
                    num1 + " ，num2 的值为：" + num2);

            // 调用swap方法
            swap(num1, num2);
            System.out.println("交换后 num1 的值为：" +
                    num1 + " ，num2 的值为：" + num2);
        }
        /** 交换两个变量的方法 */
        public static void swap(int n1, int n2) {
            System.out.println("\t进入 swap 方法");
            System.out.println("\t\t交换前 n1 的值为：" + n1
                    + "，n2 的值：" + n2);
            // 交换 n1 与 n2的值
            int temp = n1;
            n1 = n2;
            n2 = temp;

            System.out.println("\t\t交换后 n1 的值为 " + n1
                    + "，n2 的值：" + n2);
        }
    }

结果：

交换前 num1 的值为：1 ，num2 的值为：2
    进入 swap 方法
        交换前 n1 的值为：1，n2 的值：2
        交换后 n1 的值为 2，n2 的值：1
交换后 num1 的值为：1 ，num2 的值为：2

0.6方法的重载

就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。

public static int max(int num1, int num2) {   	
	int result;   
	if (num1 > num2){      
		result = num1;
    }else      
		result = num2;    
		return result;  
	}
}	

public static double max(double num1, double num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}

如果你调用max方法时传递的是int型参数，则 int型参数的max方法就会被调用；

如果传递的是double型参数，则double类型的max方法体会被调用，这叫做方法重载；

0.7变量作用域

变量的范围是程序中该变量可以被引用的部分。

方法内定义的变量被称为局部变量。

局部变量的作用范围从声明开始，直到包含它的块结束。

局部变量必须声明才可以使用。

方法的参数范围涵盖整个方法。参数实际上是一个局部变量。

for循环的初始化部分声明的变量，其作用范围在整个循环。

但循环体内声明的变量其适用范围是从它声明到循环体结束。它包含如下所示的变量声明：

img

0.8构造方法

当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。

通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。

不管你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法，默认构造方法的访问修改符和类的访问修改符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。

一旦你定义了自己的构造方法，默认构造方法就会失效。

下面是一个使用构造方法的例子：

// 一个简单的构造函数
class MyClass {
  int x;
 
  // 以下是构造函数
  MyClass() {
    x = 10;
  }
}

你可以像下面这样调用构造方法来初始化一个对象：

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.x + " " + t2.x);
   }
}

额外补充：

集合

1.数组定义和访问

1.1容器概述

1.1.1案例分析

现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有50名员工，用前面所学

的知识，程序首先需要声明50个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦，而且错

误率也会很高。因此我们可以使用容器进行操作。将所有的数据全部存储到一个容器中，统一操作。

1.1.2容器概念

**容器：**是将多个数据存储到一起，每个数据称为该容器的元素。

**生活中的容器：**水杯，衣柜，教室

1.2 数组概念

数组概念： 数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

1.3 数组的定义

1.3.1一维数组
动态初始化
int[] array = new int[3];
// 两种方式都可以
// int array[] = new int[3];
array[0] = 1;
array[1] = 2;
array[2] = 3;
System.out.println(array[0]);
静态初始化
int[] array = { 1, 2, 3, 4 };
int[] array1 = new int[] { 1, 2, 3, 4 };
System.out.println(array[2]);
System.out.println(array1[2]);
默认初始化
int[] array = new int[4];
System.out.println(array[2]);
获取数组的长度
int[] array = new int[10];
int length = array.length;
System.out.println("数组array的长度是：" + length);
1.3.2二维数组
二维数组初始化

同一维数组一样，共有4总不同形式的定义方法：

int[][] array1 = new int[10][10];
int array2[][] = new int[10][10];
int array3[][] = { { 1, 1, 1 }, { 2, 2, 2 } };
int array4[][] = new int[][] { { 1, 1, 1 }, { 2, 2, 2 } };
不定长二维数组
int[][] array = new int[3][];
array[0] = new int[1];
array[1] = new int[2];
array[2] = new int[3];
获取二维数组的长度
int length1 = array.length;
int length2 = array[0].length;
// 获取二维数组的第一维长度（3）
System.out.println(length1);
// 获取二维数组的第一维的第一个数组长度（1）
System.out.println(length2);

1.4 数组的访问

索引： 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引

(index)，可以通过数组的索引访问到数组中的元素。

格式：

数组名[索引]

数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的 长度，语句为：数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为 数组名.length-1 。

public static void main(String[] args) { 
        int[] arr = new int[]{1,2,3,4,5}; //打印数组的属性，输出结果是5     
    	System.out.println(arr.length);
}

索引访问数组中的元素：

  • 数组名[索引]=数值，为数组中的元素赋值
  • 变量=数组名[索引]，获取出数组中的元素
public static void main(String[] args) { 
    //定义存储int类型数组，赋值元素1，2，3，4，5 
    int[] arr = {1,2,3,4,5}; 
    //为0索引元素赋值为6 
    arr[0] = 6;
    //获取数组0索引上的元素 
    int i = arr[0]; 
    System.out.println(i); 
    //直接输出数组0索引元素 
    System.out.println(arr[0]); 
}

2.数组原理内存图

2.1 内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程

序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。

Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

2.2 Java虚拟机的内存划分

为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

区域名称作用
寄存器给CPU使用，和我们开发无关。
本地方法栈JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区存储可以运行的class文件。
堆内存存储对象或者数组，new来创建的，都存储在堆内存。
方法栈方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

2.3 数组在内存中的存储

2.3.1一个数组内存图
public static void main(String[] args) { 
	int[] arr = new int[3]; 
	System.out.println(arr);//[I@5f150435 
}

以上方法执行，输出的结果是[I@5f150435，这个是什么呢？是数组在内存中的地址。new出来的内容，都是在堆 内存中存储的，而方法中的变量arr保存的是数组的地址。

输出arr[0，就会输出arr保存的内存地址中数组中0索引上的元素

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BT3mgW7i-1602922548071)(https://i.loli.net/2020/10/17/PsZ6qgaV1e5QcDF.png)]

2.3.1补充：什么是引用数据类型？

Java提供了两类数据类型：一种是基本类型（原始类型），一种是引用类型。

- 数据类型图：

​ ┏数值型━┳━整数型：byte short int long

​ ┏基本数据类型━━┫ ┗━浮点型：float double

​ ┃ ┣字符型：char

数据类型╋ ┗布尔型：boolean

​ ┃ ┏类（class）

​ ┗引用数据类型━━╋接口（interface）

​ ┗数组（array）

基本数据类型

注意：

1、在基本数据类型中，除了boolean类型所占长度与平台有关外，其他数据类型长度都是与平台无关的。比如，int永远占4个字节（1 Byte = 8 bit）。

2、void不是基本数据类型

3、基本数据类型的默认值仅在作为类中属性时生效

在方法内部必须先对基本数据类型变量赋值后才能使用，否则编译不通过。Demo如下：

public class DefaultValueTest {
    static int intA;
    static boolean blnA;
    public static void main(String[] args) {
        int intB;
        boolean blnB;
        System.out.println(intA); //输出0
        System.out.println(blnA); //输出false

        //System.out.println(intB); //编译不通过
        //System.out.println(blnB); //编译不通过
    }
}

在程序中如果某些数据可能会返回空值，那么用包装类比较好。比如当结果为空时，转换为int会发生异常，而转换为Integer则不会，因为对象可以为null。此时建议用包装类，虽然会牺牲一些转换效率，但可以避免持久化数据时产生的一些异常。

- 引用数据类型

引用类型（reference type）指向一个对象，不是原始值，指向对象的变量是引用变量。

在java里面除去基本数据类型的其它类型都是引用数据类型，自己定义的class类都是引用类型，可以像基本类型一样使用。

引用类型常见的有：String，StringBuffer，ArrayList，HashSet，HashMap等。
String也属于引用数据类型：

两种类型对比
基本数据类型引用数据类型
在栈中进行分配在堆中进行分配,堆的读写速度远不及栈
变量名指向具体的数值变量名指向存数据对象的内存地址,即变量名指向hash值
变量在声明之后java就会立刻分配给他内存空间它以特殊的方式(类似C指针)指向对象实体（具体的值），这类变量声明时不会分配内存，只是存储了一个内存地址
基本类型之间的赋值是创建新的拷贝对象之间的赋值只是传递引用
“==”和“!=”是在比较值“==”和“!=”是在比较两个引用是否相同，需要自己实现equals()方法
基本类型变量创建和销毁很快类对象需要JVM去销毁
2.3.2两个数组内存图
public static void main(String[] args) { 
	int[] arr = new int[3]; 
	int[] arr2 = new int[2]; 
	System.out.println(arr); 
	System.out.println(arr2); 
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Re3uYOqX-1602922548074)(https://i.loli.net/2020/10/17/upkF89hMTyvPXzg.png)]

2.3.3两个变量指向一个数组
public static void main(String[] args) { 
    // 定义数组，存储3个元素 
    int[] arr = new int[3]; 
    //数组索引进行赋值 
    arr[0] = 5; 
    arr[1] = 6; 
    arr[2] = 7; 
    //输出3个索引上的元素值 
    System.out.println(arr[0]); 
    System.out.println(arr[1]); 
    System.out.println(arr[2]); 
    //定义数组变量arr2，将arr的地址赋值给arr2 
    int[] arr2 = arr; 
    arr2[1] = 9; 
    System.out.println(arr[1]); 
}

image-20201017113645287.png

3.数组的常见操作

3.1 数组越界异常

观察一下代码，运行后会出现什么结果。

public static void main(String[] args) { 
    int[] arr = {1,2,3}; 
    System.out.println(arr[3]); 
}

创建数组，赋值3个元素，数组的索引就是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运 行后，将会抛出 ArrayIndexOutOfBoundsException数组越界异常。在开发中，数组的越界异常是不能出现的，一 旦出现了，就必须要修改我们编写的代码。

image-20201017113847628.png

3.1补充IDEA安装插件：

https://blog.csdn.net/qq_35246620/article/details/78289074

3.2 数组空指针异常

观察一下代码，运行后会出现什么结果。

public static void main(String[] args) { 
    int[] arr = {1,2,3}; 
    arr = null; 
    System.out.println(arr[0]); 
｝

arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候 会抛出 NullPointerException空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修 改我们编写的代码。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kM81CdSC-1602922548083)(https://i.loli.net/2020/10/17/YP7C4cXaHUMSnuf.png)]

空指针异常在内存图中的表现

image-20201017121011076

3.3 数组遍历【重点】

数组遍历： 就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

public static void main(String[] args) { 
    int[] arr = { 1, 2, 3, 4, 5 }; 
    System.out.println(arr[0]);
    System.out.println(arr[1]); 
    System.out.println(arr[2]); 
    System.out.println(arr[3]); 
	System.out.println(arr[4]); 
}

以上代码是可以将数组中每个元素全部遍历出来，但是如果数组元素非常多，这种写法肯定不行，因此我们需要改 造成循环的写法。数组的索引是 0 到lenght-1 ，可以作为循环的条件出现。

传统方式遍历
int[] array = new int[] { 1, 2, 3 };
for (int i = 0; i < array.length; i++) {
    System.out.println("array[" + i + "] = " + array[i]);
}
增强for循环方式遍历
int[] array = new int[] { 1, 2, 3 };
for (int i : array) {
    System.out.println(i);
}

3.4 数组获取最大值元素

**最大值获取：**从数组的所有元素中找出最大值。

实现思路：

  • 定义变量，保存数组0索引上的元素
  • 遍历数组，获取出数组中的每个元素
  • 将遍历到的元素和保存数组0索引上值的变量进行比较
  • 如果数组元素的值大于了变量的值，变量记录住新的值
  • 数组循环遍历结束，变量保存的就是数组中的最大值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kHHvf20m-1602922548085)(https://i.loli.net/2020/10/17/fc54bYEFQ6NWmiR.png)]

public static void main(String[] args) {
int[] arr = { 5, 15, 2000, 10000, 100, 4000 }; 
//定义变量，保存数组中0索引的元素 
int max = arr[0]; 
//遍历数组，取出每个元素
for (int i = 0; i < arr.length; i++) { 
	//遍历到的元素和变量max比较 
	//如果数组元素大于max 
	if (arr[i] > max) { 
		//max记录住大值 max = arr[i]; 
		} 
	}
	System.out.println("数组最大值是： " + max); 
}

3.4数组排序

int[] array = { 3, 2, 1, 4, 5 };
Arrays.sort(array);
System.out.println(Arrays.toString(array));

常用的排序方法有冒泡排序、快速排序、选择排序、插入排序、希尔（Shell）排序、堆排序。可参考Java 数组排序

**3.5 **数组反转

数组的反转： 数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1

**实现思想：**数组最远端的元素互换位置。

  • 实现反转，就需要将数组最远端元素位置交换
  • 定义两个变量，保存数组的最小索引和最大索引
  • 两个索引上的元素交换位置
  • 最小索引++，最大索引–，再次交换位置
  • 最小索引超过了最大索引，数组反转操作结束

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-07nJfnIA-1602922548086)(https://i.loli.net/2020/10/17/746vNPJmiT5nIxe.png)]

public static void main(String[] args) {
	int[] arr = { 1, 2, 3, 4, 5 }; 
	/*
	 循环中定义变量min=0最小索引
     max=arr.length‐1最大索引 
     min++,max‐‐
     */ 
    for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) { 
    //利用第三方变量完成数组中的元素交换 
        int temp = arr[min]; 
        arr[min] = arr[max]; 
        arr[max] = temp; 
    }
    // 反转后，遍历数组 
    for (int i = 0; i < arr.length; i++) { 
    	System.out.println(arr[i]); 
    }
}

4.数组作为方法参数和返回值

4.1 数组作为方法参数

以前的方法中我们学习了方法的参数和返回值，但是使用的都是基本数据类型。那么作为引用类型的数组能否作为 方法的参数进行传递呢，当然是可以的。

数组作为方法参数传递，传递的参数是数组内存的地址。

public static void main(String[] args) {
    int[] arr = { 1, 3, 5, 7, 9 };
    //调用方法，传递数组 
    printArray(arr); 
}
    /* 
	创建方法，方法接收数组类型的参数 
	进行数组的遍历 
	*/
public static void printArray(int[] arr) { 
	for (int i = 0; i < arr.length; i++) {
		System.out.println(arr[i]); 
	}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6GQpP7hT-1602922548087)(https://i.loli.net/2020/10/17/FcWLqXYCSoNtzMI.png)]

4.2 数组作为方法返回值

数组作为方法的返回值，返回的是数组的内存地址

public static void main(String[] args) { 
	//调用方法，接收数组的返回值 
	//接收到的是数组的内存地址 
	int[] arr = getArray(); 
	for (int i = 0; i < arr.length; i++) {
    	System.out.println(arr[i]);
    }
}
/*
	创建方法，返回值是数组类型
    return返回数组的地址 
*/
public static int[] getArray() { 
	int[] arr = { 1, 3, 5, 7, 9 };
    //返回数组的地址，返回到调用者 
    return arr;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3RdqaROO-1602922548089)(https://i.loli.net/2020/10/17/WTk8J62suIdlBYz.png)]

4.3 方法的参数类型区别

代码分析

1. 分析下列程序代码，计算输出结果。

public static void main(String[] args) {
	int a = 1;
    int b = 2; 
    System.out.println(a); 
    System.out.println(b); 
    change(a, b); 
    System.out.println(a); 
    System.out.println(b); 
}
public static void change(int a, int b) {
	a = a + b;
    b = b + a;
}

2. 分析下列程序代码，计算输出结果。

public static void main(String[] args) { 
	int[] arr = {1,3,5}; 
	System.out.println(arr[0]); 
	change(arr);
    System.out.println(arr[0]);
}
public static void change(int[] arr) {
	arr[0] = 200; 
}

4.4总结:

方法的参数为基本类型时,传递的是数据值.方法的参数为引用类型时,传递的是地址值.

5.实用API

  1. String static toString(type[] a): 将书中的元素拼接成一个字符串

    //toString()方法
String[] arr1 = {"Hello", "world", "I'm", "Michael"};

System.out.println(Arrays.toString(arr1));

  2. type static valueOf(type[] a, int length); 将数据按照传入的长度拷贝到一个新的数组中

  3. type static copyOfRange(type[] a, int start, int end); 将源数组按照传入的开始位置和结束位置拷贝到一个新的数组中;

  4. static void sort(type[] a); 将源数组按照优化的快速排序法进行排序

    int[] arr2 = {10,3,21,45,99,4};

Arrays.sort(arr2);

System.out.println(Arrays.toString(arr2));

  5. static int binarySearch(type[] a, type v); 在整个数组中按照二分查找法查找数据，查找成功返回下标，否则返回-1；

  6. static int binarySearch(type[] a, int start, int end, type v); 在整个数组中按照二分查找法从传入的开始位置和结束位置查找数据，查找成功返回下标，否则返回-1；

  7. static void fill(type[] a, type v); 将数组中的所有元素值都设置为v;

  8. static boolean equals(type[] a, type[] b,); 如果两个数组的长度和每个元素值都相等，那么返回true,否则返回false

  9. String static deepToString(type[] a); 将二维数组拼接为字符串形式

补充（自己了解）：

Scanner类
Scanner sc = new Scanner(System.in); System.out.println("请录入一个整数：");
int i = sc.nextInt();
Random类

以下代码使用户能够得到一个随机数：

Random r = new Random(); 
int i = r.nextInt();
String类
  1. 字符串不变：字符串的值在创建后不能被更改。
  2. 因为String对象是不可变的，所以它们可以被共享
  3. “abc” 等效于 char[] data={ ‘a’ , ‘b’ , ‘c’ } 。
// 无参构造 
String str = new String（）；

// 通过字符数组构造 
char chars[] = {'a', 'b', 'c'};
String str2 = new String(chars);

// 通过字节数组构造 
byte bytes[] = { 97, 98, 99 };
String str3 = new String(bytes);
咖色的杯
关注
专栏目录
java 通用数组_Java中的通用数组
weixin_36108931的博客
02-13 100
基本上，泛型和数组不会混合。简短的回答是你可以解决这个问题。更长的答案是你可能不应该，我会解释原因。privateComparable[]hashtable;...hashtable=(Comparable[])Array.newInstance(Comparable.class,tableSize);但是您无法创建参数化类型的数组。数组是协变的。这意味着它们在运行时保留其元素的类型。J...
java 通用数组_java数组
weixin_39955421的博客
02-16 205
数组到目前为止，我们都是使用一个变量就声明一个变量，但是我们我们现在要声明10个整型变量，那么我们是不是需要写10行代码呢？虽然我们可以在一行代码中同时声明多个变量，写10个也不算什么，但是如果要声明50个，或者100个呢！这个时候最好的方法是使用数组组织这些数据了。一、数组的作用和组织方式数组是一个可以保存多个相同类型的变量的顺序集合，这些变量在数组中以列表的形式存在，每个信息都对应的有自己的脚...
Java基础语法（数组）
weixin_33766805的博客
10-26 192
第4天 Java基础语法 今日内容介绍 u流程控制语句（switch） u数组 第1章流程控制语句 1.1选择结构switch switch 条件语句也是一种很常用的选择语句，它和if条件语句不同，它只能针对某个表达式的值作出判断，从而决定程序执行哪一段代码。例如，在程序中使用数字1~7来表示星期一到星期天，如果想根据某个输入的数字来输出对应中文格式的星期值，可以通过下面的一段...
Java基础算法
每天进步一点点
03-17 228
目录 java_99乘法表 java_冒泡排序 java_斐波那契额数列 java_99乘法表 public class Demo1 { public static void main(String[] args) { for (int i = 1; i <10; i++) { for (int j = 1; j <= i; j++) { System.out.print(j + "*" + i + "=" + i * j + " ");
java语法基础（二）--数组
yuanxinya_的博客
10-12 365
java中一维和多维数组的使用
Java数组练习题(带答案).doc
03-15
Java数组是Java编程语言中的基本数据结构之一，用于存储固定数量的同类型元素。了解和熟练掌握数组的使用是学习Java的重要环节。本篇练习题涵盖了数组的基本概念、操作和异常处理，下面是针对题目中涉及知识点的详细...
Java数组与内存控制
09-20
### Java数组与内存控制 #### 一、Java数组在内存分配方面的知识 ##### 1.1 数组初始化 - **声明数组的时候如何分配内存：** - 在Java中，数组的声明并不直接分配内存，而仅仅是创建了一个数组引用变量。例如： ...
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
比较Java数组和各种List的性能小结
09-01
首先，Java数组是最基础的数据结构，它提供了固定大小的连续内存空间来存储相同类型的数据。由于其物理结构的特性，数组在随机访问时具有极高的效率，因为可以直接通过索引来访问元素。但是，插入和删除元素时，如果...
JAVA的初级练习
NN2016160626的博客
11-06 272
1.打印出深度5层杨辉三角形。 2.计算字符串中子串出现的次数 。 3.两个字符串连接程序。 4.输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。 解答： 1.打印出深度5层杨辉三角形。 public class PascalTriangle { public static int[][] getPascalTriangle(int nmax) {...
(七)：final与static final变量(原生类型)的初始化方式
lukuijun1981的专栏
02-27 714
[code="java"]public class FinalOriginalTest { private final int a; private String name; public FinalOriginalTest(){ a = 3; } public FinalOriginalTest(String name){ this.name = name; ...
Java基础静态变量、静态方法
03-21 1175
编写带参方法计算两门课程考试成绩的平均分，通过方法的参数传入成绩信息 public class HelloWorld { public static void main(String[] args) { // 创建对象，对象名为hello HelloWorld hello = new HelloWorld(); // 调用方法，传入两门课程的成绩
java笔记-static（静态）关键字
zhuhengv的博客
12-09 347
静态：static 用法：是一个修饰符，用于修饰成员（成员变量，成员函数） 当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用 static特点： a.随着类的加载而加载，随着类的消失而消失 b.优先于对象存在 c.被所有对象所共享 d.可以被类名调用 实例变量与类变量的区别 a.存放位置：类变量随着类的加载而存在于方法区中；实
public static 类名 方法名（） { }
热门推荐
mao_xiaoxi的博客
04-11 1万+
例子： public static ImageUtilEngine getImageEngine() { return imageEngine; } 注解： 一个方法的格式： 权限修饰符 返回值类型 方法名（）{ 函数体} （1）权限修饰符：public、private、default（空的） （2）返回值类型：void（无返回值）、int、string、等等，例子中返回的是个...
简单编程（二十二）编写顺序查找的方法public static int[] ordinalSearch(int data[],int key)
张志昌 的专栏
12-16 1586
编写顺序查找的方法public static int[] ordinalSearch(int data[],int key)，要求该方法返回一个数组（如果key存在，数组中各元素的值分别为关键字key在原数组data中的各下标；如果key不存在，则返回一个长度为1的数组，数组元素为-1）。public class sfrlh { public static int[] ordinalSearc
Java中的数组的介绍与使用
suwu150
08-06 1万+
目标： 1. 数组的创建和使用 定义： 数组是指一组数据的集合，数组中的每个数据称为元素。在Java中，数组也是Java对象。数组中的元素可以是任意类型(包括基本类型和引用类型),但同一个数组里只能存放类型相同的元素。 创建数组大致包括如下步骤： . 声明一个数组类型的引用变量，简称为数组变量； . 用new语句构造数组的实例。new语句为数组分配内存，并且为数组中的每个元素赋予默认值； . 初始化，即为数组的每个元素设置合适的初始值。 一. 数组变量的声明；
求给定的两个数组的公共元素，并将其返回为一个数组
Java 之 道
08-04 3113
如数组a:1,3,4,5,6,7,2 数组b:3,6,0,2 则方法返回数组c:{2,3,6} package test3; import java.util.Arrays; public class findCommonData { public static int[] getCommon(int []array1, int []array2){ int[] arra
java求三个数中的最大数,JAVA_新建一个方法并且求三个数中的最大值
weixin_42388485的博客
03-22 1627
package wac.wev.as;//新建一个方法在求最大值import java.util.Scanner;public class MaxLian {public static void main(String[] args){//键盘录入以及导包Scanner sc= new Scanner(System.in);//数据接收System.out.println("请输入第一个数据:")...
java 数组
最新发布
05-30
Java 数组是一种用于存储同一类型数据的集合。它们是基本数据结构之一，非常重要，被广泛应用于各种算法和数据处理场景中。 Java 数组可以存储基本类型数据（如 int、float、double 等）以及对象类型（如 String、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

咖色的杯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值