【黑马程序员】StringBuffer,Array,Integer,BigInteger,Date,Calendar,集合——Java复习笔记

StringBuffer

(1)用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了一个字符串缓冲区类:StringBuffer供我们使用。

(2)StringBuffer的构造方法
A:StringBuffer()
B:StringBuffer(int size)
C:StringBuffer(String str)
//不能把字符串的值直接赋值给StringBuffer

(3)StringBuffer的常见功能(ABCD功能的方法返回值都是StringBuffer，E功能返回的是String)

A:添加功能 append添加  insert插入
append()方法返回的是本身，不是新对象

StringBuffer sb = new StringBuffer();
StringBuffer sb2 = sb.append(“hello”);
Sout(sb1+”,”+sb2);//输出hello,hello

如果sb2也是new的 则输出 ，hello

insert(index,str)从index位置开始插入 str变成该位置元素 该位置原有元素右移

B:删除功能
deleteCharAt(index) 删除指定位置的字符并返回本身
delete(start,end) 删除从指定位置开始指定位置结束的内容并返回本身，删除的内容包括start不包括end

C:替换功能 replace(start,end,str)

D:反转功能 reverse()

E:截取功能(注意这个返回值)
substring(start)
substring(start,end) 截取后返回的是String对象,StringBuffer还是原来的内容（未被截取）

(4)String和StringBuffer相互转换
String —> StringBuffer
构造方法new StringBuffer(str) 或者 append()方法，建议构造方法

StringBuffer —> String
构造方法new String(sb)  或者 toString()方法，建议toString

(5)面试题
A:String,StringBuffer,StringBuilder的区别
String是内容不可变 另外俩都是内容可变
StringBuffer：同步的，数据安全，效率低。
StringBuilder：不同步的，数据不安全，效率高。
安不安全都是指的多线程情况下，一般单线程不会有安全问题

B:StringBuffer和数组的区别?
SB不管添加什么类型数据，都是作为字符串放进去的
数组只能放同一类型的数据，是什么类型就是什么类型

(6)注意的问题：
String是一种特殊的引用类型，作为形式参数时当做基本数据类型看，形参改变，实参不变
StringBuffer作为形式参数若直接赋值，则形参变，实参不变。若调用了方法，则实参改变
(7)练习
判断字符串是否为对称的  两个方法
方法1

public static boolean isSymmetic(String s ){
StringBuffer sb = new StringBuffer(s);
for (int x= 0;x<sb.length()/2;x++){
if (sb.charAt(x) != sb.charAt(sb.length()-x-1)){
return false;
}
}
return true;
}

方法2

public static boolean isSymmetic2(String s ){
return new StringBuffer(s).reverse().toString().equals(s);
}

数组高级以及Arrays工具类

(1)排序
A:冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。同理，其他的元素就可以排好。

/**
* 冒泡排序
* 比较第一轮后 最大值出现在末尾,下次不用比较倒数1,2数
* 比较第二轮后 第二大值出现在倒数第二位,下次不用比较倒数2,3数
* ....
* 总共比较 arr.length-1轮  每比较完一轮,下轮就少比较一次
*/
public static int[] maoPao(int[] arr){
for (int x = 0; x<arr.length -1 ;x++){
for (int i = 1; i<arr.length-x;i++){
if (arr[i] < arr[i-1]){
arr[i-1] = arr[i-1] ^ arr[i];
arr[i] = arr[i-1] ^ arr[i];
arr[i-1] = arr[i-1] ^ arr[i];
}
}
}
return arr;
}

B:选择排序
把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。

/**
* 选择排序
* 从0开始 依次和后面的元素比较,小的往前放,一轮后最小值到了首位   比较了arr.length-1次
* 从1开始 依次和后面的元素比较,小的往前放,一轮后第二小的值到了第二位  比较了arr.length-2次
* ....
* 总共比较arr.length-1轮,
*/

public static int[] xuanZe(int[] arr){

for (int x = 0 ; x<arr.length-1 ; x++){

for (int i = x+1; i<arr.length;i++){
if (arr[x] > arr[i]){     //每一轮都是用固定的位置和其他位置比较
arr[x] = (arr[x]+arr[i])-(arr[i]=arr[x]); //交换数据
}
}
}
return arr;
}

(2)查找
A:基本查找
针对数组无序的情况。一个一个找

B:二分查找(折半查找)
针对数组有序的情况(千万不要先排序再查找。无意义)

/**
* 折半查找(二分查找)
* 前提:数组有序
* 核心:每次都找中间的元素进行比较,没找到则下次查找工作量减半
* 注意:二分查找对无序数组无意义,要用基本查找(一个一个找)
*/

public static int findMe(int[] arr,int key){
arr = xuanZe(arr);
System.out.println("排序后得:");
System.out.println(Arrays.toString(arr));

int min = 0 , max = arr.length-1;
int mid = (min+max)/2;

while (key != arr[mid]){
//            if (mid == 0 || mid == arr.length-1){     //或者min>max
//                return -1;
//            }
if (key > arr[mid]) {
min = mid + 1;
}else {
max = mid - 1;
}
mid = (min+max)/2;

if (min>max){
return -1;
}
}
return mid;
}

(3)Arrays工具类
要掌握的方法
把数组转成字符串：toString
排序： sort    //底层方法是快速排序
二分查找：binarySearch

(4)Arrays工具类的源码解析
开发原则：只要是对象，就要判断该对象是否为null，内容是否为空

二分查找源码：

int low = fromIndex;    //0
int high = toIndex - 1;     //arr.length-1
while (low <= high) {
int mid = (low + high) >>> 1; //无符号右移1位即mid/2
int midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid;     // key found
}
return -(low + 1);   // key not found.

(5)练习
对字符串中的字符进行排序

/**
* 对字符串中的字符进行排序 选择排序冒泡排序都可以
* @param arr
* @return
*  字符串转数组:toCharArray方法
*  数组转字符串:String的构造方法 or String的valueOf方法 or Array工具类的toString方法
*/
public static String xuanZe(char[] arr){

for (int x = 0 ; x<arr.length-1 ; x++){

for (int i = x+1; i<arr.length;i++){
if (arr[x] > arr[i]){     //每一轮都是用固定的位置和其他位置比较
arr[x] = (char)((arr[x]+arr[i])-(arr[i]=arr[x])); //交换数据
}
}
}
return String.valueOf(arr);
}

Integer类

(1)为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型
byte        Byte
short       Short
int         Integer
long        Long
float       Float
double      Double
char        Character
boolean     Boolean

(2)Integer的构造方法

Integer i = new Integer(100);
Integer i = new Integer(“100”); //这里的字符串必须是由数字字符组成

(3)String和int的相互转换
A:String -- int 两种方法
1 Integer.parseInt("100”); //重点推荐此种，记住
2 new Integer(“100”).intValue();

B:int -- String 四种方法
1 String.valueOf(100);  //推荐此种方法 可把任意类型转成字符串
2 String s = “” + 100;
3 String s = newInteger(100).toString();
4 String s = Integer.toString(100);

(4)其他的功能
int范围 Integer.MAX_VALUE     MIN_VALUE

进制转换 Integer.toBinaryString   toHexString  toOctalString 这三个方法都是十进制转其他进制，返回值都是字符串
十进制到N进制 Integer.toString(int s,N);    2 <= N <= 36  返回值为String
N进制到十进制 Integer.parseInt(“1024”,N)  //要转换的数要作为字符串传进去

(5)JDK5的新特性
自动装箱    把基本类型—>包装类类型
自动拆箱    包装类类型—>基本类型

把下面的这个代码理解即可：
Integer i = 100; // JDK5以后可以这么写。原来应该是Integer i = new Integer(100);
i += 200;  //i转int类 加完后再转回Integer
注意：若Integer x = null;则会出现空指针异常。 所以用之前先判断是否为空

(6)面试题

Integer i = 127;
Integer i3 = 128;
Integer i2=127;
Integer i4 = 128;

i==i2;//true
i3==i4;//false

这样赋值，实际上编译器会编译成调用valueOf方法赋值，通过查看源码得知，对-128~127之间的数据做了数据缓冲池，如果数据在该范围内,则赋值时不创建新空间,直接从缓冲池内获取数据；若不在该范围内则new Integer()

Character

(1)Character构造方法只有一个
Character ch = new Character('a');

(2)要掌握的方法：(都是静态，直接通过类名调用)
A:判断给定的字符是否是大写 isUpperCase
B:判断给定的字符是否是小写 isLowerCase
C:判断给定的字符是否是数字字符 isDigit
D:把给定的字符转成大写    toUpperCase
E:把给定的字符转成小写    toLowerCase

正则表达式

(1)就是符合一定规则的字符串

(2)常见规则
A:字符
x 字符 x。举例：'a'表示字符a
\\ 反斜线字符。
\n 新行（换行）符 ('\u000A')
\r 回车符 ('\u000D')

B:字符类
[abc] a、b 或 c（三选一）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
[0-9] 0到9的字符都包括

C:预定义字符类
. 任何字符。我的就是.字符本身，怎么表示呢? \.
\d 数字：[0-9]
\w 单词字符：[a-zA-Z_0-9]
在正则表达式里面组成单词的东西必须有这些东西组成

D:边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
就是不是单词字符的地方。
举例：hello world?haha;xixi

E:Greedy 数量词
X? 一次或零次
X* 零次或多次
X+ 一次或多次
X{n} 恰好 n 次
X{n,} 至少 n 次
X{n,m} 至少 n 次，但是不超过 m 次

(3)常见功能：
A:判断功能
String类的public boolean matches(String regex)

B:分割功能
String类的public String[] split(String regex)

C:替换功能
String类的public String replaceAll(String regex,String replacement)

D:获取功能
Pattern和Matcher

Pattern p = Pattern.compile(“a*b”);//将匹配规则编译到Pattern对象中
Matcher m = p.matcher("aaaaab”);//通过Pattern对象得到匹配器对象并将被匹配数据传入匹配器中
boolean b =m.matches();//true   可用链式编程简化 但还是不如直接用matches方法简单

find():查找存不存在
group():获取刚才查找过的数据，调group前必须先调find，不然会报错

(4)练习
1. 分割字符串并排序然后转回字符串

/**
* 分割功能split案例
* 分割字符串并排序然后转回字符串
*
* 分割-转int数组-排序
*/
String s = "18 25 103 32 95 39";
String regex = " ";//空格分割
//split方法得到每个数字的字符串数组
String[] ss = s.split(regex);

//创建int数组
int[] arr = new int[ss.length];
//遍历String数组 并转为int放入int数组
int i =0;
for (String x:ss){
System.out.print(x+" ");
arr[i] = Integer.parseInt(x);
i++;
}
//排序
Arrays.sort(arr);
//换行
System.out.println();
///转回字符串输出
StringBuilder sb = new StringBuilder();
for (int x=0;x<arr.length;x++){
if (x == arr.length-1){
sb.append(arr[x]);
}else {
sb.append(arr[x]+" ");
}
}
System.out.println(sb.toString());

2. 替换功能replaceAll

String s = "hello3149world841java09";
//        String regex = "\\d+"; //相邻数字全替换为一个星
String regex = "\\d"; //每个数字替换一个星
s = s.replaceAll(regex,"*");
System.out.println(s);

3. 获取功能

//find
String s = "da kjk ijqro dsaj iq rqjfa ;qieru ais dq a iiq r sad d sd ewq tr";
String regex = "\\b\\w{3}\\b"; //要加入单词边界,这样才匹配的整个单词
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);

//        boolean flag = m.find(); //find方法查找有没有满足条件的子串
//        String ss = m.group();  //group获取查找到的值  调用group前必须先调find 不然会报错
//        System.out.println(ss);

while(m.find()){    //找到就打印
System.out.println(m.group());
}

Math

常见方法
A:绝对值 abs  返回值int
B:向上取整 ceil  返回值double
C:向下取整 floor 返回值double
D:两个数据中的大值 max min
E:a的b次幂 pow(a,b)  返回值double
F:随机数 random    [0.0~1.0)
G:四舍五入 round 返回值int
H:正平方根 sqrt  返回值double

练习:设计一个方法 获取任意范围的随机数

public static int getRandom(int start,int end){
return  (int)(Math.random()*(end-start+1)+start); //end-start+1得到范围总数 乘random得到随机数 然后再+start然随机数取值从最小值开始
}

Random类

(1)用于产生随机数的类

(2)构造方法:
A:Random() 默认种子，是当前时间的毫秒值，每次产生的随机数不同
B:Random(long seed) 指定种子，每次种子相同，随机数就相同
给定种子后，每次得到的随机数都一样

(3)成员方法:
A:int nextInt() 返回int范围内的随机数
B:int nextInt(int n) 返回[0,n)范围内的随机数

System

(1)系统类,提供了一些有用的字段和方法

(2)成员方法
A:运行垃圾回收器 gc
执行System.gc前，系统会自动调用finalize方法清除对象占有的资源，子类重写finalize方法，通过super.finalize方式可以实现从下到上的finalize方法调用，即先释放自己的资源，再去释放父类的资源

B:退出jvm
exit(int) 终止当前正在运行的Java虚拟机，参数用作状态码，非0表示异常终止。一般要退出给0就行

C:获取当前时间的毫秒值
currentTimeMillis 一般应用在计算运行时间，程序运行前后各获取一次，相减得程序运行时间。

D:数组复制(这个方法名特殊，全小写)
arraycopy(Object src,int srcPos,Object dest,int destPos,int length) 从数组中复制一个数组，从指定位置开始到指定位置结束
--src 原数组;
--srcPos 原数组中的起始位置;
--dest 目标数组;
--destPos 目标数据中的起始位置;
--length 要复制的数组元素的数量
复制后目标数组的长度不会变，新数据会覆盖旧数据。

int[] arr = {11,22,33,44,55};
int[] arr2={6,7,8,9,10};
System.arrcopy(arr,1,arr2,2,2);
//打印出来arr数组不变，arr2变成{6,7,22,33,10}

BigInteger

(1)针对大整数的运算

(2)构造方法
BigInteger(String s)

(3)成员方法
A:加 add
B:减 subtract
C:乘 mutiply
D:除 divide
E:商和余数 divideAndRemainder  返回的是商和余数的数组

BigDecimal

(1)浮点数据做运算，会丢失精度。所以，针对浮点数据的操作建议采用BigDecimal。(金融相关的项目)

(2)构造方法
BigDecimal(String s)

(3)成员方法：
A:加减乘除同BigInteger

B:自己保留小数几位 divide(BigDecimal bd除数,int scale商的小数有几位,int roundingMode商要应用的舍入模式)

Date/DateFormat(掌握)

原始时间1970年1月1日0点

(1)Date是日期类，可以精确到毫秒。
A:构造方法
Date() 根据默认毫秒值创建日期对象
Date(long time) 根据给定的毫秒值time创建日期对象

B:成员方法
getTime() 获取时间 以毫秒为单位
setTime(long time) 设置时间

C:日期和毫秒值的相互转换
日期转毫秒值  new Date().getTime();
毫秒值转日期  setTime(time)或new Date(time);

(2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormat
A:SimpleDateFormat(String pattern) 给定模式
yyyy-MM-dd HH:mm:ss  其他表示方式查看API

B:日期和字符串的转换
a:Date --> String（格式化）
format()
b:String --> Date（解析）
parse()
(3)练习:写一个程序计算你来到这个世界多少天

import java.text.ParseException;
import java.util.Scanner;

/**
* Created by mo on 15/11/8.
* 你来到这个世界多少天
*
* 出生年月日转为Date
* getTime
* 获取当前时间毫秒值
* 相减再除以每天的毫秒值
*/

public class DateTest {
public static void main(String[] args) throws ParseException {
System.out.println(MyDays());
}

public static long MyDays() throws ParseException {

System.out.println("请输入出生年月日,格式为:yyyy-MM-dd");
Scanner sc = new Scanner(System.in);
String birthday = sc.nextLine();

long birth = DateUtil.stringToDate(birthday,"yyyy-MM-dd").getTime();
long today = System.currentTimeMillis();
return (today-birth)/86400000;
}

/**
* 字符串转日期对象
* @param date
* @param parsePattern 被转换的日期格式
* @return Date对象
* @throws ParseException
*/
public static Date stringToDate(String date,String parsePattern) throws ParseException{
return new SimpleDateFormat(parsePattern).parse(date);
}
}

Calendar类

(1)日历类
装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。

(2)如何得到一个日历对象呢?
Calendar rightNow = Calendar.getInstance(); //获取当前日历时间

getInstance本质返回的是子类对象，Calendar是抽象类

(3)成员方法
A:根据日历字段得到对应的值
int year = Calendar.getInstance().get(Calendar.YEAR); //month,date同理.month从0开始，即0表示1月

B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值 add(Calendar.DATE,-5) //日期-5天。add方法无返回值，执行add方法后再重新获取值

C:设置日历对象的年月日 set(int year,int month,int date)