Javaweb微专业第六讲-----数组与字符串
有时候我们需要一组相同数据类型的变量，这时候我们就要用数组来实现
数 组：用于存储同一类型数据的一个容器。好处：可以对该容器中的数据进行编号，从0开始。数组用于封装数据，就是一个具体的实体。
一、数组的相关操作
1.数组声明、初始化、属性
1.1数组声明的几种方式
type[] 变量名 = new type[数组中元素的个数];
type 变量名[] = new type[数组中元素的个数];
type[] 变量名 = new type[]{逗号分隔的初始化值};
type[] 变量名 = {元素1，元素2…}；
2.数组的几种初始化方式
方式一
String[] strs = new String[2];
strs[0] = "0";
strs[1] = "1";方式二
String[] strs = new String[]{"0", "1"};方式三
String[] strs = {"0", "1"};3.属性
获取数组长度：数组名.length
2.数组的几种遍历方法
2.1 for循环遍历(其他循环遍历也可以)
int[] a = new int[10] ;
for(int i=0;i0;
} 2.2 for-each循环
for(int t:a){
System.out.println(t);
}注:这里t就是数组元素的拷贝，不能通过t来修改数组元素的值
3.数组的排序、查找
3.1 数组的排序
3.1.1 冒泡排序
public void bubbleSort(int a[]) {
for (int i = 0; i < a.length - 1; i++){
for (int j = 0; j < a.length - 1; j++){
if (a[j] > a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
} 3.1.2 选择排序
public void selectSort(int a[]) {
for (int n = a.length; n > 1; n--) {
int i = max(a,n);
int temp = a[i];
a[i] = a[n - 1];
a[n - 1] = temp;
}
} 3.1.3 插入排序
public void insertSort(int a[]) {
for (int i = 1; i < a.length; i++) {
int t = a[i];
int j;
for (j = i - 1; j >= 0 && t < a[j]; j--) {
a[j + 1] = a[j];
}
a[j + 1] = t;
}
} 3.1.4 Arrays.sort()方法:
import java.util.Arrays; //导入包
public class Main {
public static void main(String[] args) {
int a[] = new int[10];
Arrays.sort(a);
}
}3.2 数组的查找
3.2.1 二分查找法
public static int binarySearch(int[] arr,int key){
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (max+min)>>1; //(max+min)/2;
while(arr[mid]!=key){
if(key>arr[mid]){
min = mid + 1;
}
else if(key1;
if(maxreturn -1;
mid = (max+min)>>1;
}
return mid;
} 3.2.2 用Arrays类进行二分查找
public static int binarySearch(Object[] a, Object key);
例如
Arrays.binarySearch(a, 10);
4.Arrays 类
java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
给数组赋值：public static void fill(int[] a, int val)。
对数组排序：public static void sort(Object[] a)，按升序。
比较两个数组是否相等：public static boolean equals(long[] a, long[] a2)
二分查找数组元素：public static int binarySearch(Object[] a, Object key)
数组拷贝:Arrays.copyOf(original, newLength)
original – 这是要被复制的数组。
newLength – 这是要返回的副本长度。
System.arraycopy(src, srcPos, dest, destPos, length);
通过查看Arrays的源码可以发现实际上:Arrays.copyOf(original, newLength)内部是调用的System.arraycopy(src, srcPos, dest, destPos, length);
5.二维数组
5.1声明与初始化
int[][] arr = new int[2][3];
int[][] arr = new int[2][];
int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};5.2 二维数组的遍历
1.for循环遍历二维数组
public class Test {
public static void main(String[] args) {
int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
}
}
2.两层for-each循环
public class Test {
public static void main(String[] args) {
int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
for (int[] is : arr) {
for (int i : is) {
System.out.println(i);
}
}
}
}
5.3二维数组 的几个问题
1.二维数组的定义格式
int[][] arr = new int[2][]; 可以。
int[][] arr = new int[][3]; 不可以。一定要先给行，在考虑列。
2.int[] x,y[];请问x和y有区别吗？
有区别，x是一维数组，y是二维数组。
二、字符串的相关操作
1.字符串创建
String str=”“;
string str=new String();
注：
a.实际运用中，我们要避免第二种方式，第二种方式创建了两个String对象。首先，通过双引号创建了String对象“abc”。然后，java虚拟机创建一个新的String对象，并把字符串“abc”传入构造函数。这是一次完全没有必要的构造，既影响了性能，也提高了代码阅读难度。
b.这两个对象创建的时期不同,一个是编译时，一个是运行时.
c.String str=”hello”;JVM先根据内容查找对象，如果没找到，则heap上面创建新对象,并将其赋予s1,否则使用已经存在的对象
d.string str=new String(“hello”); jvm直接在heap上创建新的对象,所以在heap中会出现内容相同而地址不同的String对象.
2.字符串的拼接
str=”hello”+”world”
aa.concat(str)
3.字符串的属性与方法
3.1.获取字符串长度
a.length();
3.2 特殊字符
回车 ‘\r’
换行 ‘\n’
Tab ‘\t’
换页 ‘\f’
退格 ‘\b’
单引号 ‘\’
换码符 ‘\’
双引号 ‘\”’
4.String类
4.1 不可修改性
通过String类的源码的我们，value[]属性是final的。这代表一个String对象是不可改变的，String类的方法中我们也找不到任何能够改变字符串的值和长度的方法。这就是字符串的不可改变性
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];4.2不能被继承
因为final是最终意思，final限定的类是最终类，没有其子类。所以不能够被继承。关于继承这个概念会在第八讲面向对象详细说明。
4.3 String对象的方法
String类的equals()方法用来确定两个字符串是否相等
charAt()用以得到指定位置的字符
getChars()用以得到字符串的一部分字符串
subString()是提取字符串的另一种方法，它可以指定从何处开始提取字符串以及何处结束
replace()方法可以将字符串中的一个字符替换为另一个字符
toUpperCase()和toLowerCase()方法分别实现字符串大小写的转换
trim()方法可以将字符串中开头和结尾处的空格去掉.
String类提供静态方法valueOf(),它可以将任何类型的数据对象转换为一个字符串。
我们说String类是不可变字符序列，如果频繁的修改，将会产生很多的String对象，开销很大。有时候我们需要用到可变字符序列，jdk为我们提供了StringBuffer类与StringBuilder类。
4.4 String对象的intern()方法
5.StringBuffer类
StringBuffer对象的每次修改都会改变对象自身，这点是和String类最大的区别。StringBuffer是线程安全的(后续笔记中，将讲到多线程编程)。
5.1 StringBuffer创建
StringBuffer sb = new StringBuffer();
StringBuffer sb = new StringBuffer(“xiaoqingchun”);
5.2 StringBuffer的常用方法
StringBuffer reverse()；
int lastIndexOf(String str, int fromIndex);
int lastIndexOf(String str);
int indexOf(String str, int fromIndex);
int indexOf(String str);
StringBuffer insert(int offset, double d)；
String substring(int start, int end);
CharSequence subSequence(int start, int end)；
StringBuffer replace(int start, int end, String str);
StringBuffer deleteCharAt(int index);
StringBuffer delete(int start, int end)
append();
注:不能通过String常量来赋值，String不存与StringBuffer在继承关系，无法进行强转
6.StringBuilder类
6.1 创建
StringBuilder sb= new StringBuilder(“xiaoqingchun!”);
6.2 常用方法
| 方法 | 作用 |
|---|---|
| StringBuilder append(Object obj) | 将文本或对象的字符串表示形式添加到由当前 StringBuilder对象表示的字符串的结尾处 |
| StringBuilder delete(int start, int end) | 删除指定start-end位置的字符串 |
| StringBuilder deleteCharAt(int index) | 删除指定索引位置的字符 |
| StringBuilder replace(int start, int end, String str) | 可以用另一个指定的字符来替换 StringBuilder对象内的字符 |
| StringBuilder insert(int offset, Object obj) | 方法将字符串或对象添加到当前 StringBuilder中的指定位置 |
| int indexOf(String str) | 求出第一次出现str字符串的位置 |
| int lastIndexOf(String str) | 求出最后一次出现str字符串的位置 |
| StringBuilder reverse() | 翻转字符串 |
| void ensureCapacity(int minimumCapacity) | 设置长度 |
7.String,StringBuffer与StringBuilder的区别
7.1 效率比较
通常情况下 : 三者在执行速度方面的比较：StringBuilder > StringBuffer > String
但是一定是这样的嘛，接下来我们来看4个栗子
栗子1 ：
(1)String str = “This is only a” + “simple”+ ” test”;
(2)StringBuffer buffer= new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
这里(1)的效率比(2)的效率高，这是因为jvm在编译的时候，已经直接进行了表达式合并优化，只开辟了一段内存。而编译StringBuffer还要进行append处理，花的时间要长一些
栗子2 ：
(1) String str = “This is only a”;
str += “simple”;
str += “test”;
(2)StringBuffer buffer= new StringBuffer (“This is only a”).append(“ simple”).append(“ test”);
(1)的效率优于(2)的效率，因为String是不可变对象，，每次”+=”都会创造新的String对象
栗子3 ：
(1)StringBuffer buffer= new StringBuffer ();
for(int i=0;i<50000;i++){
buffer.append(“hello”);
}
(2)StringBuffer buffer= new StringBuffer (250000);
for(int i=0;i<50000;i++){
buffer.append(“hello”);
}
第一周效率比第二种好，因为StringBuffer内部实现是char数组,默认初始化长度为16,每次字符串长度大于char数组长度的时候，JVM会构造新数组，并将原先的数组内容复制到新数组.方法二避免了复制数组的开销。
栗子4 ：
(1)private static void test2(String s1,String s2) {
return s1+s2;
}
(2)private static void test2(String s1,String s2) {
return new StringBuffer().append(s1).append(s2);
}
1与2的效率相同，因为JVM会开辟一个内存段,再合并(扩展)内存，所以两者执行的过程是一致的
上述案例可以用一下测试来进行测定
public class Test {
public static void main(String[] args) {
test1();
test2();
}
private static void test1() {
Runtime run = Runtime.getRuntime();
long startTime, endTime;
long startMem, endMem;
System.out.println("方法1");
run.gc();//回收一下垃圾
// 记录开始时的内存及时间信息,并打印到屏幕上
startTime = System.currentTimeMillis();
startMem = run.totalMemory() - run.freeMemory();
System.out.println("开始时候使用的: " + startMem);
for (int i = 0; i < 10000; i++) {
// 执行需要测试的代码段
String str = "This is only a" + "simple"+ " test";
}
// 计算花费的内存及时间,然后打印到屏幕上
endTime = System.currentTimeMillis();
endMem = run.totalMemory() - run.freeMemory();
System.out.println("运行时间:" + (endTime - startTime));
System.out.println("结束时所用内存: " + endMem + ", 增加使用的内存:" + (endMem - startMem));
}
private static void test2() {
Runtime run = Runtime.getRuntime();
long startTime, endTime;
long startMem, endMem;
System.out.println("方法1");
//回收一下垃圾
run.gc();
// 记录开始时的内存及时间信息,并打印到屏幕上
startTime = System.currentTimeMillis();
startMem = run.totalMemory() - run.freeMemory();
System.out.println("开始时候使用的: " + startMem);
//微小放大法
for (int i = 0; i < 10000; i++) {
// 执行需要测试的代码段
StringBuffer sb = new StringBuffer("This is only a").append("simple").append(" test");
}
// 计算花费的内存及时间,然后打印到屏幕上
endTime = System.currentTimeMillis();
endMem = run.totalMemory() - run.freeMemory();
System.out.println("运行时间:" + (endTime - startTime));
System.out.println("结束时所用内存: " + endMem + ", 增加使用的内存:" + (endMem - startMem));
}
}7.2 StringBuilder与 StringBuffer的比较
1.StringBuffer线程安全、效率相对低
2.StringBuilder线程不安全、效率相对高
7.3StringBuffer面试关键点:
(1)简单地认为.append()效率好于”+”是错误的。
(2)不要使用new创建String
(3)注意.intern()的使用
(4)在编译期能够确定字符串值的情况下,使用”+”效率最高
(5)避免使用”+=”来构造字符串
(6)在声明StringBuffer对象的时候,指定合适的capacity,不要使用默认值16
(7)注意下面两个的区别,后者开辟了两个内存段
1. String s=”a”+”b”;
2. String s= “a”;
s +=”b”;
7.4 一些面试题
1.请看下面的写法有没有区别? 假设s是一个字符串。
第一种写法:
if(s.equals("world")) {
}第二种写法：
if("world".equals(s)) {
}答案:有却别.如果s是外界传递的一个参数，可能别人传递一个null。这个时候，前者就会有空指针异常。后者没有问题。
推荐：在判断的时候把常量写在前面。