一维数组的创建以及使用

一维数组的声明

数组遵循先声明再调用的原则

语法：

type[] arrayName;    // 数据类型[] 数组名 //(常用);

或者

type arrayName[];    // 数据类型 数组名[];

第一种格式 type[] arrayName，很容易理解这是定义一个变量，其中变量名是 arrayName，而变量类型是 type[]。

例如：

int[] score; // 存储学生的成绩，类型为整型
double[] price; // 存储商品的价格，类型为浮点型
String[] name; // 存储商品名称，类型为字符串型

注：

• 在声明数组时不需要规定数组的长度
• 在声明数组变量时千万不要漏写 []

一维数组的创建

简单来说，数组的创建就是为声明的数组分配地址空间。

语法：

arrayName = new type[size];    // 数组名 = new 数据类型[数组长度];

数组长度就是数组中能存放的元素个数，显然应该为大于 0 的整数，例如：

score = new int[10];
price = new double[30];
name = new String[20];

当然也能再声明时就分配好空间。

语法：

type[] arrayName = new type[size];    // 数据类型[] 数组名 = new 数据类型[数组长度];

例如：

int[] score = new int[10];
double[] price = new double[30];
String[] name = new String[20];

一维数组的初始化

1. 使用 new 指定数组大小后进行初始化

使用 new 关键字创建数组，在创建时指定数组的大小。语法如下：

type[] arrayName = new int[size];

创建数组之后，元素的值并不确定，需要为每一个数组的元素进行赋值，其下标从 0 开始。

创建包含 5 个元素的 int 类型的数组，然后分别将元素的值设置为 1、2、3、5 和 8。代码如下：

int[] number = new int[5];
number[0] = 1;
number[1] = 2;
number[2] = 3;
number[3] = 5;
number[4] = 8;

如果只指定了数组的长度，那么系统将负责为这些数组元素分配初始值。指定初始值时，系统按如下规则分配初始值。

数组元素的基本类型	系统分配初始值
整数类型（byte、short、int 和 long）	数组元素的值是 0
浮点类型（float、double）	数组元素的值是 0.0
字符类型（char）	数组元素的值是 ‘\u0000’（空）
布尔类型（boolean）	数组元素的值是 false
引用类型（类、接口和数组）	数组元素的值是 null

2. 使用 new 指定数组元素的值

使用上述方式初始化数组时，只有在为元素赋值时才确定值。可以不使用上述方式，而是在初始化时就已经确定值。语法如下：

type[] arrayName = new type[]{值1,值2,值3,...,值n};

使用 new 直接指定数组元素的值。代码如下：

int[] number = new int[]{1, 2, 3, 5, 8};

注：以下为错误示范，不要在进行数组初始化时，既指定数组的长度，也为每个数组元素分配初始值，这样会造成代码错误。

int[] number = new int[5] {1, 2, 3, 4, 5};

3. 直接指定数组元素的值

在上述两种方式的语法中，type 可以省略，如果已经声明数组变量，那么直接使用这两种方式进行初始化。如果不想使用上述两种方式，那么可以不使用 new 直接指定数组元素的值。语法如下：

type[] arrayName = {值1,值2,值3,...,值n};

直接使用上述语法实现 number 数组的初始化。代码如下：

int[] number = {1, 2, 3, 5, 8};

注：使用这种方式时，数组的声明和初始化操作要同步，即不能省略数组变量的类型。如下的代码就是错误的：

int[] number;
number = {1, 2, 3, 5, 8};

一维数组的访问

访问单个数组

arrayName 表示数组变量，index 表示下标，下标为 0 表示获取第一个元素，下标为 array.length-1 表示获取最后一个元素。当指定的下标值超出数组的总长度时，会抛出 ArrayIndexOutOfBoundsException （数组索引超出绑定异常）异常。

arrayName[index];

获取数组长度

在 Java 中取得数组的长度（也就是数组元素的长度）可以利用 数组名称.length，返回一个 int 型数据。

arrayName.length;

for 循环遍历数组获取全部元素

下面利用 for 循环语句遍历 number 数组中的全部元素，并将元素的值输出。代码如下：

int[] number = {1, 2, 3, 5, 8};
for (int i = 0; i < number.length; i++) {
    System.out.println("第" + (i + 1) + "个元素的值是：" + number[i]);
}

数组长度属性及其常用操作

1. 对数组进行升序

Arrays.sort(数组名);

2. 在数组中查询指定关键字

Arrays.binarySearch(数组名, 关键字);

注：binarySearch() 方法采用二分法，要求对数组必须有序排列。

二维数组的创建以及使用

二维数组的声明与创建

二维数组好比一个表格，第一个下标表示行，第二个下标表示列，数组的创建和初始化与一维数组类似，二维数组就是一个把多个一维数组包起来的数组。

声明：

type[][] arrayName;

声明之后同时分配行和列的存储空间：

type[][] arrayName = new type[][];

二维数组初始化

1. 给数组分配空间大小，不能修改，在赋值：

type[][] arrayName = new type[length1][length2];

2. 通过 new 给数组赋值，不给空间大小：

type[][] arrayName = new type[][]{{值1, 值2, 值3}, {值1, 值2, 值3}};

3. 直接给数组赋值，不分配空间大小：

type[][] arrayName = {{值1, 值2, 值3}, {值1, 值2, 值3}};

4. 数组的二维长度为空：

type[][] arrayName = new type[length1][];

二维数组的访问

访问格式：

数组名[行下标][列下标];

for 循环嵌套打印二维数组：

public class dome2 {
    public static void main(String[] args) {
        int[][] a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        for (int i = 0; i < a.length; i++) {  // 二维数组的行循环
            for (int j = 0; j < a[i].length; j++) {  // 二维数组的列循环
                System.out.print(a[i][j] + " ");  // 输出每个元素
                if (a[i][2] == a[i][j]) {  // 当每一行输出三列后换行
                    System.out.println();
                }
            }
        }
    }
}

字符串的使用

String 类的使用

（1）字符串的创建

1. 创建最简单的方法：

String str = "hello, world";

2. 构造函数创建字符串：

String str2 = new String("hello, world");

以下为不同的构造方法：

String();// 创建空字符串
String(byte[]);// 创建字符串，其值由一个字节数组的内容设置
String(char[]);// 创建字符串，其值由一个字符数组的内容设置
String(byte[], int, int);// 两个整形参数表示字节数组的偏移量和长度
String(char[], int, int);// 两个整形参数表示字符数组的偏移量和长度

（2）常用的字符串操作

• 获取字符串长度：

str.length();

• 在字符串中查找字符或字符串：

str.indexOf("world");// 从左往右查找字符在字符串中的位置
str.lastIndexOf("hello");// 从右往左查找字符在字符串中的位置

• 获取子字符串：

String sub = str.substring(0, 5);// 从索引 0 到索引 5 之前

• 比较两个字符串是否相等：

str.equals("hello");// 严格区分大小写
str.equalsIgnoreCase("HELLO");// 不区分大小写

• 字符串连接：

str.concat(" Java");// str = str + " Java";

• 删除字符串前后的空格：

str.trim();

StringBuffer 类

在 Java 语言中，由于 String 类是final 类型的，所以使用 String 定义的字符串是一个常量，因此它一旦创建，其内容和长度是不可改变的。如果需要对一个字符串进行修改，则只能创建新的字符串。

解决方法：可以使用 StringBuffer 类（也称字符串缓冲区）来操作字符串。

说明：StringBuffer 类和 String 类最大的区别在于它的内容和长度都是可以改变的。StringBuffer 类似一个字符容器，当在其中添加或删除字符时，所操作的都是这个字符容器，因此并不会产生新的 StringBuffer 对象。

1. 创建字符串变量

1. 直接初始化字符串变量。

StringBuffer sb = new StringBuffer("Hello");

2. 初始化一个空字符串。

StringBuffer sb = new StringBuffer();

StringBuffer();//创建一个空的StringBuffer对象，默认容量为16个字符
StringBuffer(int len);//创建一个空的StringBuffer对象，初始容量由参数len设定
StringBuffer(String str);//创建一个StringBuffer对象，利用一个已经存在的字符串String的对象str来初始化该对象，其容量为String对象Str的长度加16

2. 常用操作

• 1.字符串访问方法

int capacity();//获取当前字符串对象的容量
int length();//获取当前字符串对象的长度（字符数）

• 2.字符串修改方法

setCharAt(int index,char ch);

将指定的字符串ch放到index指定位置上

 StringBuffer s = new StringBuffer("Stdent");
 s.setCharAt(2,'u');

replace(int a,int b,String Str);

使用新字符串str替换当前字符串变量从起始a到结尾b

insert(int offset,chr ch)和insert(int offset，String str)

在当前字符串对象offset位置插入字符ch或字符串str

StringBuffer s = new StringBuffer("wecome");
s.insert(2,'l');

append(String str)

将给定的字符串追加到当前字符串变量的末尾

StringBuffer s = new StringBuffer("we");
String str = "lcome";
s.append(str);

deleteCharAt(int a);

删除指定索引位置处的字符

delete(int a,int b)

后用于删除当前字符串变量中从起始位置a到结束位置b的内容