JAVA基础 数组，字符串与正则表达式

数组

数组的概念

将相同类型的数据按一定顺序排列构成的大小确定的集合

数组元素类型可以为基本数据类型，也可以为引用类型

Java语言内存分配

栈内存：基本数据类型的变量或者引用类型的变量，超出作用域将自动释放 

堆内存：存放由 new 运算符创建的对象和数组。由Java虚拟机的自动垃圾回收器来管理

引用类型的变量

为数组或对象起的一个名称。在堆中创建一个数组或对象后，可在栈中定义一个引用变量存放该数组或对象在堆内存中的首地址（对象的句柄），然后可在程序中使用栈的引用变量来访问堆中的数组或对象。

数组的特点

元素的类型相同、数组长度固定（编译时常量）、存储在一段连续的内存空间中，支持随机读写、支持随机读写，通过数组的名字和元素的位置即可随机读写元素（a[i]）

一维数组

一维数组的定义：

方式1：Type[] a={a_1, …, a_n};

方式2：Type[] a=new Type[n]{a_1, …, a_n};

方式3：Type[] a=new Type[n];

数组元素的访问：a[i]，索引从 0 开始

数组长度：a.length

Java中数组是一种引用类型

数组越界会抛出 ArrayIndexOutOfBoundsException异常

遍历数组元素：三种循环结构，foreach循环：for(int x : a){循环体}，执行读操作

例子：逆序输出数组（示范）

public class App {
    public static void main(String[] args) {
        int[] a = new int[5];
        for (int i = 0; i < 5; i++) {
            a[i] = i;
        }
        for (int i = 4; i >= 0; i--) {
            System.out.println(String.format("a[%d] = %d \n", i, a[i]));
        }
        System.out.println("the length = " + a.length);
    }
}

 设数组有n个互不相同的数，不用排序求出其中的最大值和次大值

public class App {
    public static void main(String[] args) {
        int max, second;
        int[] a = new int[] { 6, 3, 8, 31, 9, 10 };
        max = a[0] > a[1] ? a[0] : a[1];
        second = a[0] > a[1] ? a[1] : a[0];
        for (int i = 0; i < 6; i++) {
            if (a[i] > max) {
                max = a[i];
            } else if (a[i] > second) {
                second = a[i];
            }
        }
        System.out.println("the max = " + max + " and the scend =" + second);
    }
}

 多维数组

即数组的数组

定义方式1：Type[][] a=new Type[m][]; 最后一维的长度可以不写，这时必须显示初始化

定义方式2：Type[][] a={{a_11, …, a_1n},{a_m1, …, a_mo}}; 每行的元素个数可以不同

定义方式3：Type[][] a=new Type[m][]{{a_11, …, a_1n},{a_m1, …, a_mo}}; 每行的元素个数可以不同

例子：输出杨辉三角

public class App {
    public static void main(String[] args) {
        int level = 8;// 层数为8层
        int[][] yanghui = new int[level][];
        yanghui[0] = new int[] { 1 };
        for (int i = 1; i < level; i++) {
            yanghui[i] = new int[i + 1];
            yanghui[i][0] = 1;
            yanghui[i][i - 1] = 1;// 初始化两边
            for (int y = 1; y < i - 1; y++) {
                yanghui[i][y] = yanghui[i - 1][y] + yanghui[i - 1][y - 1];
            }
        }
        // 输出杨辉三角
        for (int i = 0; i < level; i++) {
            for (int j = 0; j < i; j++) {
                System.out.print(yanghui[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

字符串

字符串就是一个字符序列，Java 提供了 String 和StringBuffer 两个类来封装字符串

String 对象是不可变字符串

String 字面值存放在 Java 常量池中，包括利用“+”拼接的字符串常量

StringBuffer对象是可变字符串

StringBuffer类提供了一系列方法修改字符串

字符串的两种初始化方法

String s=“Hello, World”;  // 常量池

String s=new String(“Hello, World”); // 堆栈

String 类位于 java.lang 包中，其中包含了丰富的方法

调用方式：字符串变量名.方法名(形参列表)

堆栈和常量池有什么区别呢？我们用equals和==这两个试一下，大家明显就能看出区别。注意堆栈和常量池的区别。

public class App {
    public static void main(String[] args) throws Exception {
        String s1 = "hello";
        String s2 = "hello";
        String s3 = new String("hello");
        String s4 = new String("hello");
        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
        System.out.println(s1 == s3);
        System.out.println(s1.equals(s3));
        System.out.println(s3 == s4);
        System.out.println(s3.equals(s4));

    }
}

代码结果如下：

true
true
false
true
false
true

例子：判断回文字符串 

public class App {
    public static void main(String[] args) {
        if (args.length == 0) {// 如果字符组长度为0则退出
            System.out.println("长度为0退出");
            System.exit(1);// java的退出语句，此处退出整个程序
        }
        String text = args[0];// 将第一个args赋值到text中即可操作整个字符串
        System.out.println("Text is: " + text);
        boolean isP = true;// 标志变量
        for (int i = 0; i < text.length() / 2; i++) {
            if (text.charAt(i) != text.charAt(text.length() - i - 1)) {
                isP = false;// charat方法为查询其数组的内容，若先不等于后即非回文，置标志点为false
                break;
            }
        }
        System.out.println("it is " + isP);
    }
}

 可变字符串

线程安全：StringBuffer

线程不安全：StringBuilder

创建 StringBuffer 实例（StringBuilder类似）

StringBuffer sb=new StringBuffer();

StringBuffer sb1=new StringBuffer(“Hello”);

使用 StringBuffer

sb.toString();将StringBuffer对象转换为String类型的字符串

sb.append();在StringBuffer对象的末尾追加指定的字符串

sb.insert( 位置 ， 字符 ); 在指定位置插入指定的字符串。

sb.reverse();将StringBuffer对象中的字符顺序进行反转。

sb.setCharAt(  位置 ，字符 );将指定位置的字符替换为指定的字符。

sb.setLength();设置StringBuffer对象的长度，可以用于截取或者扩展字符串。

正则表达式

正则表达式(Regular Expression，简写为regex)是一个强大的字符串处理工具。

正则表达式是一种特殊的字符串，本质上是一个字符串模板，可用于匹配常规字符串

正则表达式的作用

1.判断输入的字符串是否符合特定的要求

2.从字符串中提取特定的子串

Java中提供了专门的包（java.util.regex），用于处理正则表达式的匹配

正则表达式：Pattern 类

匹配器：Matcher 类

使用方法

调用 Pattern.compile(String regex) 生成正则表达式对象

调用 Pattern 类中的 matcher(String targetStr) 方法，生成 Matcher 对象

调用 Matcher 类中的方法，查看匹配结果

Matcher 类中的方法

find()：判断目标字符串中是否有与 Pattern 匹配的子串

group(): 返回上一次与 Pattern 匹配的子串

start(): 返回上一次与 Pattern 匹配的子串在目标字符串中的起始位置

end()：返回上一次与 Pattern 匹配的子串在目标字符串中的结束位置

matches()：整个目标字符串与 Pattern 是否匹配

reset(): 将现有的 Matcher 的对象应用于一个新的目标字符串