一、StringBuffer

1、概述

     我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题StringBuffer是线程安全的可变字符序列String与StringBuffer的区别： 如果我们要进行拼串的操作，推荐使用StringBufferStringBuffer 长度可变的字符序列String 长度不可变的字符序列  String s="abc";StringBuffer() 构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。StringBuffer 其实可以看做一个字符容器，不断的可以往这个容器中添加数据

2、构造方法

A:StringBuffer的构造方法：public StringBuffer():                无参构造方法public StringBuffer(int capacity):    指定容量的字符串缓冲区对象public StringBuffer(String str):       构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容
B:StringBuffer的方法：public int capacity()：返回当前容量。   类似于杯子的容量public int length():返回长度（字符数）。 类似于杯子装水的体积

package org.westos.demo;public class MyTest5 {public static void main(String[] args) {//StringBuffer类//public StringBuffer():无参构造方法StringBuffer sb = new StringBuffer();//获取容量System.out.println(sb.capacity());//16//获取长度System.out.println(sb.length());//0//public StringBuffer(int capacity):   指定容量的字符串缓冲区对象StringBuffer sb2 = new StringBuffer(8);System.out.println(sb2.capacity());//8//public StringBuffer(String str):       构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容StringBuffer sb3 = new StringBuffer("asdsasadasd");System.out.println(sb3.capacity());//27,等于初始容量加上字符串的长度System.out.println(sb3.length());//11System.out.println(sb3);//asdsasadasd}
}

3、StringBuffer的功能

1)添加功能

StringBuffer的添加功能:public StringBuffer append(String str):            可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身append()往容器中追加数据，可以把任意类型追加到容器中public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身.注意是在指定索引前添加注意:往容器中追加内容,返回的还是缓冲区对象本身,即可以继续调用方法

package org.westos.demo;public class MyTest6 {public static void main(String[] args) {StringBuffer sb = new StringBuffer();//public StringBuffer append(String str)往容器中追加内容,返回的还是缓冲区对象本身StringBuffer sb2=sb.append("abcdefg");StringBuffer sb3=sb.append("higk");StringBuffer sb4=sb.append("lmnopqrist");System.out.println((sb == sb2));//trueSystem.out.println((sb == sb3));//trueSystem.out.println((sb == sb4));//true//取出容器中的内容,容器中的内容会以字符串的形式返回//StringBuffer重写了toString()方法，把容器中的内容拼接好以字符串的形式返回。System.out.println(sb.toString());//abcdefghigklmnopqristStringBuffer s = new StringBuffer();//append()往容器中追加数据，可以把任意类型追加到容器中s.append(2).append("我爱你").append(3.29).append(1l);System.out.println(s.toString());//2我爱你3.291StringBuffer str = new StringBuffer("aaa");//往后面追加str.append("bbb");System.out.println(str);//aaabbbstr.insert(0,"ccc");System.out.println(str);//cccaaabbbstr.insert(3,"ddddd");System.out.println(str);//cccdddddaaabbb}
}

2)删除功能

     public StringBuffer deleteCharAt(int index):根据索引删除容器中的一个字符，返回的还是容器本身public StringBuffer delete(int start,int end):根据起始索引和终止索引删除一段内容，返回的还是容器本身,注意是左闭右开区间

public class MyTest2 {public static void main(String[] args) {/* public StringBuffer deleteCharAt(int index):根据索引删除容器中的一个字符，返回的还是容器本身public StringBuffer delete(int start,int end):根据起始索引和终止索引删除一段内容，返回的还是容器本身*/StringBuffer sb = new StringBuffer("aaabbbcccddd");System.out.println(sb.deleteCharAt(0));//aabbbcccdddStringBuffer sb2 = new StringBuffer("朝辞白帝彩云间");System.out.println(sb2.delete(0, 1));//辞白帝彩云间,左闭右开}
}

3)替换和反转功能

 A:StringBuffer的替换功能public StringBuffer replace(int start,int end,String str):   从start开始到end用str替换,返回的还是容器本身,左闭右开区间B:StringBuffer的反转功能public StringBuffer reverse():字符串反转,返回的还是容器本身从头查找该字符串，在容器中第一次出现的索引，如果找不到就返回-1int indexOf (String str)  从指定索引处开始查找该字符串第一次出现的索引，如果找不到就返回-1int indexOf (String str,int fromIndex)   从后往前找int lastIndexOf (String str)int lastIndexOf (String str,int fromIndex)

public class MyTest3 {public static void main(String[] args) {/*A:StringBuffer的替换功能public StringBuffer replace(int start,int end,String str):    从start开始到end用str替换B:StringBuffer的反转功能public StringBuffer reverse():                         字符串反转*/StringBuffer sb = new StringBuffer("朝辞白帝彩云间，千里江陵一日还。");sb.replace(0,6,"*");System.out.println(sb.toString());//*间，千里江陵一日还。System.out.println(sb.reverse());//。还日一陵江里千，间*}
}

4)截取功能

 A:StringBuffer的截取功能public String substring(int start):          从指定位置截取到末尾public String substring(int start,int end):   截取从指定位置开始到结束位置，包括开始位置，不包括结束位置;根据起始索引和终止索引，截取一段内容，以String类型返回。不会影响，容器中的内容B:注意事项注意:返回值类型不再是StringBuffer本身,而是String

public class MyTest {public static void main(String[] args) {StringBuffer sb = new StringBuffer("朝辞白帝彩云间，千里江陵一日还");String s = sb.substring(3);System.out.println(s.toString());//帝彩云间，千里江陵一日还System.out.println(sb);//朝辞白帝彩云间，千里江陵一日还System.out.println("================");StringBuffer sb2 = new StringBuffer("朝辞白帝彩云间，千里江陵一日还");String s1 = sb2.substring(0, 9);System.out.println(s1.toString());//朝辞白帝彩云间，千System.out.println(sb);//朝辞白帝彩云间，千里江陵一日还}
}

3、StringBuffer类型和String类型的相互转换

1.StringBuffer------>StringA:通过构造方法String(StringBuffer buffer): 分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。B:subString()方法,传一个0进去,截取到末尾C:toString()方法2.Stirng----->StringBufferA:通过构造方法B:通过append()、insert()方法

package org.westos.demo3;public class MyTest2 {public static void main(String[] args) {//1.Stirng----->StringBuffer//方式一：通过构造方法StringBuffer sb = new StringBuffer("abcdefg");//方式二：通过append（）、insert（）方法StringBuffer s = sb.append("hijklmn");System.out.println(sb);//abcdefghijklmnSystem.out.println(sb == s);//trueStringBuffer s1 = sb.insert(0, "我爱刘亦菲");System.out.println(sb == s1);//true//2.StringBuffer------>StringStringBuffer s2 = new StringBuffer("waijava");//方式一：采用toString（）方法String s3 = s2.toString();System.out.println(s3);//waijava//方式二：采用subString（0）方法，传一个0进去，截取到末尾String s4 = s2.substring(0);System.out.println(s4);//方式三：//通过构造方法String(StringBuffer buffer): 分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。StringBuffer stringBuffer = new StringBuffer("abcde");String s5 = new String(stringBuffer);}
}

4.案例

 案例演示需求：把数组中的数据按照指定个格式拼接成一个字符串举例：int[] arr = {1, 2, 3};输出结果："[1, 2, 3]"用StringBuffer的功能实现

package org.westos.demo3;public class MyTest3 {public static void main(String[] args) {/*  案例演示需求：把数组中的数据按照指定个格式拼接成一个字符串举例：int[] arr = {1, 2, 3};输出结果："[1, 2, 3]"用StringBuffer的功能实现*/int[] arr={1,2,3};System.out.print("[");for (int i = 0; i < arr.length; i++) {if (arr.length-1==i){System.out.println(arr[i]+"]");}else {System.out.print(arr[i]+",");}}int[] arr2={1,2,3};StringBuffer sb = new StringBuffer("[");for (int i = 0; i < arr2.length; i++) {if (arr2.length-1==i){sb.append(arr[i]).append("]");}else {sb.append(arr[i]).append(",");}}System.out.println(sb);}
}

5、StringBuffer和StringBuilder的区别

String是不可改变的，虽然是引用类型，但是是值传递StringBuffer和StringBuilder的区别他们两个的API是相同的。区别是:线程安全方面的区别StringBuffer是线程安全的，效率低StringBuilder　线程不安全的，效率高。多线程环境下，可能会存在线程安全问题StringBuilder　一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快

6、String和StringBuffer分别作为参数传递

形式参数问题String作为参数传递 String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完全可以将其看成基本数据类型数据进行传递，String类型输入值传递引用类型，作为参数传递，属于引用传递，传递的是地址值，形参的改变会影响实参。(String例外，String属于值传递)但是String字符串比较特殊，虽说String是引用类型。但是他作为参数传递，属于值传递。StringBuffer作为参数传递 ,属于引用传递，传递的是地址值，形参的改变会影响实参。

public class MyTest4 {public static void main(String[] args) {String str="abc";test(str);System.out.println(str);//abcStringBuffer sb = new StringBuffer("小妹妹");test2(sb);System.out.println(sb);//小妹妹waijava}public static void test(String str){str+="waijava";System.out.println(str);//abcwaijava}public static void test2(StringBuffer sb){sb.append("waijava");System.out.println(sb);//小妹妹waijava}
}

二、排序算法

1.冒泡排序

 思想:相邻元素两两进行比较，将大的元素向后放，经过一轮比较后，最大的元素就在最后

package org.westos.demo;import java.util.Arrays;public class MyTest {public static void main(String[] args) {int[] arr={24,69,80,57,13};//maoPao(arr);//外层循环控制轮数,比较了四轮for (int j = 0; j <4 ; j++) {//内层循环进行比较for (int i = 0; i < arr.length-1-j; i++) {if (arr[i]>arr[i+1]){int temp=arr[i];arr[i]=arr[i+1];arr[i+1]=temp;
;                }}}System.out.println(Arrays.toString(arr));}private static void maoPao(int[] arr) {//第一轮比较,比较4次,i<arr.length-1for (int i = 0; i < 4; i++) {if (arr[i]>arr[i+1]){int temp=arr[i];arr[i]=arr[i+1];arr[i+1]=temp;}}System.out.println(Arrays.toString(arr));//第二轮比较,比较3次,i<arr.length-1-1for (int i = 0; i < 3; i++) {if (arr[i]>arr[i+1]){int temp=arr[i];arr[i]=arr[i+1];arr[i+1]=temp;}}System.out.println(Arrays.toString(arr));//第三轮比较,比较2次,i<arr.length-1-1-1for (int i = 0; i < 2; i++) {if (arr[i]>arr[i+1]){int temp=arr[i];arr[i]=arr[i+1];arr[i+1]=temp;}}System.out.println(Arrays.toString(arr));//第四轮比较,比较1次,i<arr.length-1-1-1-1for (int i = 0; i < 1; i++) {if (arr[i]>arr[i+1]){int temp=arr[i];arr[i]=arr[i+1];arr[i+1]=temp;}}System.out.println(Arrays.toString(arr));}
}

2.选择排序

 从0索引处,依次和后面所有元素进行比较,将小元素向前放,这样经过一轮比较后,最小的元素就出现在了最前面

package org.westos;import java.util.Arrays;public class MyTest6 {public static void main(String[] args) {int[] arr={24,69,80,57,13};//test(arr);//外层循环控制轮数for (int j = 0; j < 4; j++) {//或者j<arr.length-1//内层循环进行比较for (int i = 1+j; i < 5; i++) {//i<arr.lengthif (arr[i]<arr[j]){int temp=arr[j];arr[j]=arr[i];arr[i]=temp;}}}System.out.println(Arrays.toString(arr));}private static void test(int[] arr) {//第一轮,比较四次for (int i = 1; i < 5; i++) {if (arr[i]<arr[0]){int temp=arr[0];arr[0]=arr[i];arr[i]=temp;}}System.out.println(Arrays.toString(arr));//第二轮:比较三次for (int i = 2; i < 5; i++) {if (arr[i]<arr[1]){int temp=arr[1];arr[1]=arr[i];arr[i]=temp;}}System.out.println(Arrays.toString(arr));//第三轮:比较2次for (int i = 3; i < 5; i++) {if (arr[i]<arr[2]){int temp=arr[2];arr[2]=arr[i];arr[i]=temp;}}System.out.println(Arrays.toString(arr));//第四轮:比较1次for (int i = 4; i < 5; i++) {if (arr[i]<arr[3]){int temp=arr[3];arr[3]=arr[i];arr[i]=temp;}}System.out.println(Arrays.toString(arr));}
}

3.直接插入排序


从1索引处开始,将后面的元素,插入到之前的有序序列,使之仍保持有序相当于:
每次拿后面的一个元素，插入到之前的一个有序序列当中，使之任保持有序.如果一个序列中只有一个元素,那就可以称作有序序列.

package org.westos;import java.util.Arrays;public class MyTest7 {public static void main(String[] args) {int[] arr={2,9,4,6,8};//test1(arr);//采用双层for循环//外层循环控制轮次for (int i = 1; i < arr.length; i++) {int j=i;for (j = i; j >0 ; j--) {if (j>0&&arr[j]<arr[j-1]) {int temp = arr[j];arr[j] = arr[j - 1];arr[j - 1] = temp;}}}System.out.println(Arrays.toString(arr));}private static void test1(int[] arr) {//外层控制轮数for (int i = 1; i < arr.length; i++) {//2.int j=i;while (j>0&&arr[j]<arr[j-1]){int temp=arr[j];arr[j]=arr[j-1];arr[j-1]=temp;/*1.此时存在一个问题,[2,3]插入1时,只是3和1交换了位置采取i--又与上文的i++相冲突,采取定义int j=i的方式*///3.不断的-可能导致为负数j--;}}System.out.println(Arrays.toString(arr));}
}

4.快速排序

原理:
分治法：比大小，再分区
1.从数组中取出一个数，作为基准数。
2.分区：将比这个数大或等于的数全放到他的右边，小于他的数全放到他的左边。
3.再对左右区间重复第二步，直到各区间只有一个数。实现过程:
挖坑填数
1.将基准数挖出形成第一个坑。
2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
4.再重复执行2，3两步骤。

package org.westos.demo2;import java.util.Arrays;public class MyTest8 {public static void main(String[] args) {int[] arr={5,3,9,1,6,7,2,4,0,8};/*挖坑填数1.将基准数挖出形成第一个坑。2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。4.再重复执行2，3两步骤。*/MyTest8.quickSort(arr,0,arr.length);System.out.println(Arrays.toString(arr));}public static void quickSort(int[] arr,int start,int end){if (start<end){int index = getIndex(arr, start, arr.length - 1);//递归对左右两个分区进行排序quickSort(arr,start,index-1);quickSort(arr,index+1,end);}}//找到索引public static int getIndex(int[] arr,int start,int end){int i=start;int j=end;//定义首坑int x=arr[i];while (i<j){//由后向前找比他小的数，找到后挖出此数填到前一个坑中。while (i<j&&arr[j]>=x){j--;}if (i<j){arr[i]=arr[j];//再从i后的数找i++;}///前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。while (i<j&&arr[i]<x){i++;}if (i<j){arr[j]=arr[i];j--;}}//循环结束时,将第一个坑数填给最后一个坑arr[i]=x;return i;}
}

5.希尔排序

是对插入排序的一种优化,关键在合理的选取增量;
插入排序其实就是增量为1的插入排序

package org.westos.demo;import java.util.Arrays;public class MyTest9 {public static void main(String[] args) {int[] arr={44,52,67,99,70,88,23,37};//shellSort(arr);//System.out.println(Arrays.toString(arr));/*shellSort2(arr);System.out.println(Arrays.toString(arr));*/shellSort3(arr);System.out.println(Arrays.toString(arr));}//此处存在问题:打印的不是想要的结果public static void shellSort3(int[] arr){//选取数组长度的一半,效率不高,采用克努特序列:/** 克努特序列:* h=1;* h=3*h+1;* *///求第一次的增量int k=1;while (k<=arr.length/3){k=k*3+1;}System.out.println(k);for (int h = k; h > 0; h=(h-1)/3) {for (int i = h; i < arr.length; i++) {for (int j = i; j > h - 1; j -= h) {if (arr[i] < arr[j - h]) {change(arr, i, j - h);}}}}}//对增量进行优化/* public static void shellSort2(int[] arr){for (int h = arr.length/2; h > 0; h/=2) {for (int i = h; i < arr.length; i++) {for (int j = i; j > h - 1; j -= h) {if (arr[i] < arr[j - h]) {change(arr, i, j - h);}}}}}*//* public static void shellSort(int[] arr){//定义增量int h=4;for (int i = h; i < arr.length; i++) {for (int j = i; j > h-1; j-=h) {if (arr[i]<arr[j-h]){change(arr,i,j-h);}}}//重新定义增量h=2;for (int i = h; i < arr.length; i++) {for (int j = i; j > h-1; j-=h) {if (arr[i]<arr[j-h]){change(arr,i,j-h);}}}h=1;for (int i = h; i < arr.length; i++) {for (int j = i; j > h-1; j-=h) {if (arr[i]<arr[j-h]){change(arr,i,j-h);}}}}*///定义一个交换的方法public static void change(int[] arr,int i,int j){int temp=arr[i];arr[i]=arr[j];arr[j]=temp;}
}

三.二分查找

从中间元素开始,判断要查找的值属于左区还是右区;然后在左区或右区里再次进行判断,如此往复,直至找到为止前提是  数组必须有序

package org.westos.demo2;import java.util.Arrays;public class MyTest2 {public static void main(String[] args) {int[] arr={66,55,888,111,900};//二分查找的前提是数组必须有序.对数组进行排序,每次都去查找中间的元素Arrays.sort(arr);//现在的arr={55,66,111,888,900};int test = test(arr,66);System.out.println(test);}//二分查找获取指定值的索引public static  int test(int[] arr,int num){int maxIndex=arr.length-1;int minIndex=0;int midIndex=(maxIndex+minIndex)/2;while (minIndex<=maxIndex) {if (num > arr[midIndex]) {minIndex = midIndex + 1;midIndex = (maxIndex + minIndex) / 2;} else if (num == arr[midIndex]) {return midIndex;} else {maxIndex = midIndex - 1;midIndex = (maxIndex + minIndex) / 2;}}return -1;}
}

四.Arrays工具类

A:Arrays类概述针对数组进行操作的工具类。提供了排序，查找等功能。B:成员方法public static String toString(int[] a)       将int类型的数组转换为String类型的字符串,与以前使用的StringBuffer转String效果相同 public static void sort(int[] a)       对int类型的数组进行排序public static int binarySearch(int[] a,int key)二分查找指定值的索引static boolean equals(int[] a, int[] a2) 比较两个数组中的元素，是否一样static int[] copyOf(int[] original, int newLength)  复制旧数组中的元素到一个新的数组中，新的数组长度是newLength 从0开始复制旧数组,多出来的长度里的值默认为0static int[] copyOfRange(int[] original, int from, int to) 复制旧数组中的指定范围间的几个元素到新数组中  参数 from 起始索引 to终止索引  含头不含尾,多余元素默认为0

package org.westos;import java.util.Arrays;
import java.util.Comparator;public class MyTest3 {public static void main(String[] args) {int[] arr={20,40,30,50,90};String string = Arrays.toString(arr);System.out.println(string);//"[20,40,30,50,90]"//从小到大,进行升序排序Arrays.sort(arr);System.out.println(arr);//打印的是地址值System.out.println(Arrays.toString(arr));//"[20, 30, 40, 50, 90]"int[] arr2={9,7,99,2255,222};//对指定的索引中间的元素进行升序排列Arrays.sort(arr2,2,arr2.length-1);System.out.println(Arrays.toString(arr2));Integer[] arr3={9,7,99,2255,222};Arrays.sort(arr3, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {//return o1-o2;//表示升序return o2-o1;//表示降序}});System.out.println(Arrays.toString(arr3));//[2255, 222, 99, 9, 7]System.out.println(Arrays.binarySearch(arr3, 99));//3int[] arr4={10,20,30};int[] arr5={10,20,30};System.out.println(Arrays.equals(arr4,arr5));//trueint[] arr6={10,20,30,40,50}   ;int[] arr7={10,20,30,40,50}   ;int[] arr8 = Arrays.copyOf(arr6, 6);System.out.println(Arrays.toString(arr8));int[] arr91 = Arrays.copyOfRange(arr7, 0, 8);System.out.println(Arrays.toString(arr91));}
}

五.包装类

1.包装类的概述

A: 需求:a:将100转换成二进制 , 八进制 , 十六进制：可以使用除k取余法,但是不符合面向对象思想,包装类里有三个方法toBinaryString、toOctalString、toHexString，分别表示转换为二进制，八进制，十六进制b:判断一个数是否在int的范围内包装类里定义了两个静态字段（变量）：static int MAX_VALUE值为 2^31－1 的常量，它表示 int 类型能够表示的最大值。static int MIN_VALUE值为 －2^31 的常量，它表示 int 类型能够表示的最小值B:为什么会有基本类型包装类为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.C:常用操作:   常用的操作之一：用于基本数据类型与字符串之间的转换。D:基本类型和包装类的对应byte          Byteshort           Shortint                Integerlong         Longfloat           Floatdouble         Doublechar          Characterboolean            Boolean

public class MyTest4 {public static void main(String[] args) {//Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段(成员变量)。int num=200;//转换为二进制String s = Integer.toBinaryString(num);//转换为八进制String s1 = Integer.toOctalString(num);//转换为十六进制String s2 = Integer.toHexString(num);System.out.println(s);//11001000System.out.println(s1);//310System.out.println(s2);//c8/*  static int MAX_VALUE值为 2^31－1 的常量，它表示 int 类型能够表示的最大值。static int MIN_VALUE值为 －2^31 的常量，它表示 int 类型能够表示的最小值*/if (33333>=Integer.MIN_VALUE&&33333<=Integer.MAX_VALUE){System.out.println("33333在范围内");}}
}

2.Integer类的概述和构造方法

     A:Integer类概述Integer 类在对象中包装了一个基本类型 int 的值,该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法Integer包装类里有三个方法toBinaryString、toOctalString、toHexString，分别表示转换为二进制，八进制，十六进制该包装类里有两个静态常量:static int MAX_VALUE值为 2^31－1 的常量，它表示 int 类型能够表示的最大值。static int MIN_VALUE值为 －2^31 的常量，它表示 int 类型能够表示的最小值B:构造方法public Integer(int value)构造一个新分配的 Integer 对象，它表示指定的 int 值。public Integer(String s)   构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。要一个字面上是数字的字符串，如“100”，如果不是就会报错注意：Inteter 这个类重写toString() 会打印他包装的值Integer 重写了equals()比较的是两个他包装的值是否相同
其他方法：
public static int parseInt(String s)
将字符串参数作为有符号的十进制整数进行解析int i3 = Integer.parseInt("300000");System.out.println(i3);//300000

public class MyTest5 {public static void main(String[] args) {/* Integer( int value)构造一个新分配的 Integer 对象，它表示指定的 int 值。Integer(String s)构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。*///把一个基本类型转为Integer类型Integer integer = new Integer(222);/* public Integer(String s)   构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。要一个字面上是数字的字符串，如“100”，如果不是就会报错*///报一个NumberFormatException数字格式化异常//Integer aaa = new Integer("aaa");Integer integer1=new Integer("2000");}
}

3.String类和int类的相互转换

 int--->String方式一：拼接空串String str=100+"";方式二：String类中的静态方法valueOf（）int num=100；String str=String.valueOf(num);方式三：将int转换为Integer后，再转为Stringint num=999；Integer i=new Integer（num）；String str=num.toString();String--->int类型方式一：先将String类型转为integer类型,再使用intValue（）方法转为int类型String str="2000";Integer i=new Integer(str);int num=str.intValue();方式二：使用Integer里的静态方法parseInt（）String str=“9999”；int num=Integet.parseInt（str）；

4.JDK5的新特性：自动装箱与自动拆箱

 A:JDK5的新特性自动装箱：把基本类型转换为包装类类型自动拆箱：把包装类类型转换为基本类型自动装箱的本质其实就是：当我们给一个Integer对象赋一个int值的时候，会调用Integer类的静态方法valueOf自动装箱：Integer i = 100;自动拆箱+自动装箱：i += 200;B:注意事项在使用时，Integer  x = null;代码就会出现NullPointerException。建议先判断是否为null，然后再使用。

package org.westos.demo;public class MyTest8 {public static void main(String[] args) {//自动装箱与自动拆箱int num=200;//不采用自动装箱Integer integer1 = new Integer(num);//自动装箱,会自动提升num到Integer类型Integer integer2=num;//自动拆箱,将引用类型转换为int类型Integer i=9999;int j=i+1999;//手动装箱和手动拆箱//手动拆箱Integer a=3000;Integer b=3000;int i1 = a.intValue();int i2 = b.intValue();//手动装箱int c=9999;int d=99991;int e=100000;Integer integer3= new Integer(c);Integer integer4 = new Integer(d);Integer integer5 = Integer.valueOf(e);Integer integer6=null;if (integer6 != null) {System.out.println(integer6 + 20);}}
}

注意：
intValue（）返回的是一个int类型的值，所以是Integer类型的对象来调用并返回一个int类型的值，用在自动拆箱
valueOf（）Integer重写了这一经静态方法，传一个int类型的值进去，返回一个Integer类型的值，通过类名调用，用在自动装箱

5.面试题

看程序写结果Integer i1 = new Integer(127);Integer i2 = new Integer(127);System.out.println(i1 == i2);//falseSystem.out.println(i1.equals(i2));//trueSystem.out.println("-----------");Integer i3 = new Integer(128);Integer i4 = new Integer(128);System.out.println(i3 == i4);//falseSystem.out.println(i3.equals(i4));//trueSystem.out.println("-----------");//自动装箱 在内部会调用 Integer.valueOf(128) 装箱//在Integer类里面有一个静态的内部类IntegerCache他有一个静态代码块，当Integer类一加载，静态的的内部类IntegerCache也加载，IntegerCache他里面的静态代码块也得加载。静态代码块里面会有一个Integer cache[];这个数组//这个数组里面，放的就是一些提前创建好的Interge对象。// 当我们采用 Integer i7 = 127;这种方式定义一个Integer对象时，如果值在 -128到127 之前，他会从cache[]数组中返回一个对象给你，否则返回一个新对象Integer i5 = 128;Integer i6 = 128;System.out.println(i5 == i6);//falseSystem.out.println(i5.equals(i6));//trueSystem.out.println("-----------");Integer i7 = 127;Integer i8 = 127;System.out.println(i7 == i8);//trueSystem.out.println(i7.equals(i8));//true

分析:
自动装箱的本质：
当我们给一个Integer对象赋一个int值的时候，
会调用Integer类的静态方法valueOf，如果看看valueOf的源代码就知道发生了什么。


public static Integer valueOf(int i) {if (i >= IntegerCache.low && i <= IntegerCache.high)return IntegerCache.cache[i + (-IntegerCache.low)];return new Integer(i);}其中，IntegerCache是Integer的内部类，
private static class IntegerCache {static final int low = -128;static final int high;static final Integer cache[];static {// high value may be configured by propertyint h = 127;String integerCacheHighPropValue =sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");if (integerCacheHighPropValue != null) {try {int i = parseInt(integerCacheHighPropValue);i = Math.max(i, 127);// Maximum array size is Integer.MAX_VALUEh = Math.min(i, Integer.MAX_VALUE - (-low) -1);} catch( NumberFormatException nfe) {// If the property cannot be parsed into an int, ignore it.}}high = h;cache = new Integer[(high - low) + 1];int j = low;for(int k = 0; k < cache.length; k++)cache[k] = new Integer(j++);// range [-128, 127] must be interned (JLS7 5.1.7)assert IntegerCache.high >= 127;}private IntegerCache() {}}由此，可以得出结论，当范围在-128~127之间时，返回同一个地址值；当范围不在-128~127范围内饰，返回一个新地址值

6.其他包装类

Long、Character、Boolean、Double

package org.westos.demo;public class MyTest92 {public static void main(String[] args) {long num=666l;Long l=num;System.out.println(l);//666Long l1=new Long(999);Long l2=new Long("888");System.out.println(l1);//999System.out.println(l2);//888System.out.println(l1.longValue());System.out.println(l2.longValue());Long aLong = Long.valueOf(777);Long aLong1 = Long.valueOf("555555");Long aLong2 = Long.valueOf("88888", 9);//注意,第二个参数为进制System.out.println(aLong);//777System.out.println(aLong1);//555555System.out.println(aLong2);//59048char ch='A';Character c=ch;Character character1 = new Character('M');Character character2 = new Character('M');char c1 = character1.charValue();char c2 = character1.charValue();System.out.println(c1);System.out.println(c2);Character a = Character.valueOf('A');Character b = Character.valueOf('9');Character c3 = Character.valueOf('9');System.out.println(a);//ASystem.out.println(b);//9System.out.println(c3);//9/*  static boolean isDigit ( char ch)确定指定字符是否为数字。static boolean isLetter ( char ch)确定指定字符是否为字母。static boolean isLowerCase ( char ch)确定指定字符是否为小写字母。static boolean isUpperCase ( char ch)确定指定字符是否为大写字母。static boolean isWhitespace ( char ch)确定指定字符依据 Java 标准是否为空白字符。*/System.out.println(Character.isDigit('a'));System.out.println(Character.isLetter('a'));System.out.println(Character.isLowerCase('a'));System.out.println(Character.isUpperCase('a'));System.out.println(Character.isWhitespace(' '));System.out.println("============");boolean b1=true;Boolean aBoolean=b1;System.out.println(aBoolean);Boolean boo1=new Boolean(true);Boolean boo2=new Boolean(b1);Boolean boo3=new Boolean("true");System.out.println(boo1.booleanValue());Boolean aBoolean1 = Boolean.valueOf("false");System.out.println(aBoolean1);System.out.println("==================");double d=3.14;Double aDouble = new Double(d);Double aDouble2 = new Double("666.55");System.out.println(aDouble);//3.14System.out.println(aDouble2);//666.55System.out.println(aDouble.intValue());System.out.println(aDouble2.intValue());Double aDouble3 = Double.valueOf("999.99");Double aDouble4 = Double.valueOf("666.00");System.out.println(aDouble3);System.out.println(aDouble4);}
}

五、正则表达式

1.概述

规则字符在java.util.regex Pattern类中正则表达式的判断功能：String类的功能：public boolean matches(String regex)判断一个字符串数据，符不符合，我们这个传入的正则表达式如::str.matchs(regx);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]在正则表达式里面组成单词的东西必须有这些东西组成\s 匹配空格字符 D:边界匹配器^ 行的开头 $ 行的结尾 \b 单词边界就是不是单词字符的地方。举例：hello world?haha;xixiE:Greedy 数量词 X? X，一次或一次也没有 比如""空串 就是没有X* X，零次或多次  大于等于1次 都算多次X+ X，一次或多次X{n} X，恰好 n 次 X{n,} X，至少 n 次 X{n,m} X，至少 n 次，但是不超过 m 次

package org.westos.demo;public class MyTest93 {public static void main(String[] args) {//定义正则表达式String regx="[a]";regx="[a,b,c]";//表示小写字母regx="[a-z]";regx="[A-Z]";regx="[0-9]";regx="[a-zA-Z0-9]";//不是0-9regx="[^0-9]";//匹配任意单个字符regx=".";//匹配任意两个字符regx="..";//只想匹配.可以采用转义字符\\regx="\\.";//或者regx="|";//只想匹配|,采用转义字符regx="\\|";regx="\\w";//表示"[a-zA-Z_0-9]",包含下划线regx="\\W";//表示[^\w],取反regx="\\d";//跟[0-9]意思一样regx="\\D";//跟 [^0 - 9] 意思一样regx="\\s";//匹配空格字符//?表示出现一次或一次都没有regx="a?b?";regx="[a-z]?";//* 表示出现0次或多次,大于等于一次,都算多次regx="a*";regx="[a-z0-9A-Z]*";// +出现一次或多次regx="a+";regx="[a-z0-9A-Z]+";regx="a{3}";//恰好3次regx="\\w{6}";//不得少于6次regx="[0-9]{6,}";regx="[a-z]{6,12}";//大于等于6,小于等于12//看"a"是否符合正则表达式regxboolean matches = "a".matches(regx);System.out.println(matches);}
}

案例：
验证手机号
要求：
以1开头,长度为11
第二个为3,4,…9

package org.westos.demo;import java.util.Scanner;public class MyTest6 {public static void main(String[] args) {//以1开头,长度为11//第二个为3,4,...9Scanner sc = new Scanner(System.in);System.out.println("请输入手机号");String s = sc.nextLine();//方式一:boolean b = test(s);System.out.println(b);//方式二:采用正则表达式String regx="[1][3-9][0-9]{9}";}public static boolean test(String s) {boolean flag = false;if (s.length() == 11 && s.startsWith("1") && s.charAt(1) != 0 && s.charAt(1) != 0 && s.charAt(1) != 2) {for (int i = 2; i < s.length(); i++) {if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {flag = true;} else {flag = false;break;}}} else {flag=false;}return flag;}
}

案例二：
要求：
必须是5 - 15 位数字
0 不能开头

package org.westos.demo;import java.util.Scanner;public class MyTest94 {public static void main(String[] args) {/* 1:要求必须是5 - 15 位数字2:0 不能开头*/Scanner sc = new Scanner(System.in);System.out.println("请输入要验证的数");String s = sc.nextLine();String regx="[1-9][0-9]{4,14}";System.out.println(s.matches(regx));}
}

案例三：校验邮箱
网易邮箱的规则
6～18 个字符，可使用字母、数字、下划线，需要以字母开头

public class MyTest95 {public static void main(String[] args) {//网易邮箱的规则//  6～18 个字符，可使用字母、数字、下划线，需要以字母开头String regx="[a-zA-Z]\\w{5,17}@163\\.com";//qq邮箱,8-12String regx2="[1-9][1-9]{7,11}@qq\\.com";//私人邮箱String regx3="[a-zA-Z]\\w{5,17}@[a-z0-9]{2,12}\\.(com|net|cn|org)";}
}

2.正则表达式的分割和替换功能

正则表达式的分割功能  split()方法String类的功能：public String[] split(String regex)
正则表达式的替换功能:replaceAll()方法String类的功能：public String replaceAll(String regex,String replacement)

import java.util.Arrays;public class MyTest96 {public static void main(String[] args) {//正则表达式的分割功能  split()方法// String类的功能：public String[] split(String regex)String str="李白-杜甫-王维";//截取李白,杜甫和王维String s1 = str.substring(0, str.indexOf('-'));String s2 = str.substring(str.indexOf('-')+1, str.lastIndexOf('-'));String s3 = str.substring(str.lastIndexOf('-')+1);System.out.println(s1);System.out.println(s2);System.out.println(s3);//使用正则表达式String[] split = str.split("-");System.out.println(Arrays.toString(split));//[李白, 杜甫, 王维]//上述方法有一个问题,当字符串不规整时,无法截取String string="李白=1adsaduasdasy杜甫=ugddasgh12312ASDASDA王维=NASJDJooo";//采用正则表达式进行切割String[] split1 = string.split("[=a-zA-Z0-9]+");System.out.println(Arrays.toString(split1));//正则表达式的替换功能//       String类的功能：public String replaceAll(String regex,String replacement)String string2="李白=1adsaduasdasy杜甫=ugddasgh12312ASDASDA王维=NASJDJooo";String s = string2.replaceAll("李白", "*");String s4 = string2.replaceAll("杜甫", "*");String s5 = string2.replaceAll("王维", "*");System.out.println(s4);String s6=string2.replaceAll("李白|杜甫|王维","*");System.out.println(s6);String s7 = string2.replaceAll("[=a-z0-9A-Z]", "=");System.out.println(s7);}
}

案例:需求：我有如下一个字符串:”91    27   46 38     50”，请写代码实现最终输出结果是：”27 38 46 50 91”
分析:
首先发现打印的数组是有序的,证明排过序,因此需要对数组进行排序,
但是不能直接对字符串数组进行排序,否则会按照字面上的第一个数字进行排序如:
如:str="111,97,22,55,890";
排序后的结果就为:111,22,55,890,97,不是想要的结果
因此需要先将切割后的字符串数组转为int数组,排序完成后再转换为String类型的字符串

package org.westos.demo2;import java.util.Arrays;public class MyTest4 {public static void main(String[] args) {String str="91    27   46 38        50";String regx="\\s+";String[] split = str.split(regx);String string = Arrays.toString(split);System.out.println(string);//注意:不能直接对字符串进行排序,会按照字面上的第一个数字进行排序//如:str="111,97,22,55,890";//排序后的结果就为:111,22,55,890,97,不是想要的结果int[] arr=new int[split.length];for (int i = 0; i < split.length; i++) {int i1 = Integer.parseInt(split[i]);arr[i]=i1;}Arrays.sort(arr);String string1 = Arrays.toString(arr);System.out.println(string1);}
}

3.Pattern和Matcher

Pattern :模式器, 封装一个正则表达式
Matcher 匹配器, 通过模式器，封装一个正则表达式经典的格式为:Pattern p = Pattern.compile("a*b");Matcher m = p.matcher("aaaaab");boolean b = m.matches();1.将字符串转换为模式器对象Pattern p = Pattern.compile("a*b");2.通过模式器对象创建匹配器对象Matcher m = p.matcher("aaaaab");3.进行匹配boolean b = m.matches();指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。boolean find ()尝试查找与该模式匹配的输入序列的下一个子序列。String group ()返回由以前匹配操作所匹配的输入子序列注意:一定要先使用find()方法先找到 才能用group()方法获取出来

案例:

需求：获取下面这个字符串中由三个字符组成的单词String str="da jia ting wo shuo, jin tian yao xia yu, bu shang wan zi xi, gao xing bu?";

package org.westos.demo2;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class MyTest5 {public static void main(String[] args) {String str="da jia ting wo shuo, jin tian yao xia yu, bu shang wan zi xi, gao xing bu?";String regx="\\b[a-z]{3}\\b";Pattern p=Pattern.compile(regx);Matcher m=p.matcher(str);//boolean b = m.find();//直接传一个b进去,第一个找到就为true,会一直打印第一个单词while (m.find()) {System.out.println(m.group());}}
}

六.常用类

1.Math类

 A:Math类概述Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。 B: 成员变量public static final double E :      自然底数public static final double PI:      圆周率C:成员方法public static int abs(int a)       取绝对值public static double ceil(double a) 向上取整public static double floor(double a)    向下取整public static int max(int a,int b)      获取最大值public static int min(int a, int b)    获取最小值public static double pow(double a,double b) 获取a的b次幂public static double random()   获取随机数 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。public static int round(float a) 四舍五入public static double sqrt(double a)获取正平方根

public class MyTest {public static void main(String[] args) {//Math类System.out.println(Math.PI);//3.141592653589793System.out.println(Math.E);//2.718281828459045System.out.println(Math.abs(-10));//10System.out.println(Math.ceil(9.5));//10.0System.out.println(Math.floor(9.5));//9.0System.out.println(Math.max(2, 3));//3System.out.println(Math.min(2.0, 3));//2.0System.out.println(Math.pow(2, 3));//8.0System.out.println(Math.random());//0.9902534937540173System.out.println(Math.round(5.4));//5System.out.println(Math.round(5.5));//6System.out.println(Math.sqrt(4));System.out.println(Math.sqrt(5));}
}

2.Random类

A:概述:用来生成随机数
B:构造方法public Random()            没有给定种子,使用的是默认的(当前系统的毫秒值)public Random(long seed)        给定一个long类型的种子,给定以后每一次生成的随机数是相同的
C:成员方法public int nextInt()//没有参数 表示的随机数范围 是int类型的范围public int nextInt(int n)//可以指定一个随机数范围 void nextBytes(byte[] bytes)  生成随机字节并将其置于用户提供的空的 byte 数组中。

package org.westos.demo;import java.util.Random;public class MyTest2 {public static void main(String[] args) {//Random类//无参构造Random random = new Random();//没有参数,默认以当前的系统毫秒值为时间戳for (int i = 0; i < 8; i++) {int i1 = random.nextInt(10);//第一次结果为8 2 9 5 7 0 0 8//第二次结果为8 3 5 7 0 2 9 4//System.out.print(i1);}//有参构造,传入一个参数作为一个种子,表示以后每次生成的随机数是相同的Random random1 = new Random(100L);for (int i = 0; i < 8; i++) {//第一次结果为:5 0 4 8 1 6 6 8//第二次结果为:5 0 4 8 1 6 6 8System.out.print(random1.nextInt(10));}Random random2 = new Random();byte[] arr=new byte[8];random2.nextBytes(arr);System.out.println(arr);//[B@677327b6//生成1-100之间的随机数for (int i = 0; i < 8; i++) {//生成小数double v = Math.random() * 100 + 1;//生成整数int m = (int)Math.random() * 100 + 1;System.out.println(v);System.out.println(m);}// random3.nextDouble()与Math.random()一模一样for (int i = 0; i < 8; i++) {Random random3 = new Random();int i1 = random3.nextInt(100) + 1;System.out.println(i1);double v = random3.nextDouble();System.out.println(v);}}
}

3.System类

 A:System类的概述System 类包含一些有用的类字段和方法。它不能被实例化。他里面的成员变量和成员方法都是static修饰的，使用类名调用流:读写数据public static final InputStream in“标准”输入流。此流已打开并准备提供输入数据。通常，此流对应于键盘输入public static final PrintStream out“标准”输出流。此流已打开并准备接受输出数据。通常，此流对应于显示器输出B:成员方法public static void gc()调用垃圾回收器public static void exit(int status)退出java虚拟机 0 为正常退出 非0为 异常退出计算机元年：1970 01-01 00:00:00public static long currentTimeMillis()获取从计算机元年到现在所间隔的毫秒值static String getenv (String name)获取指定的环境变量值。getProperty()获取系统变量的值
*/

public class MyTest3 {public static void main(String[] args) {//System类/*public static final InputStream in“标准”输入流。此流已打开并准备提供输入数据。通常，此流对应于键盘输入public static final PrintStream out“标准”输出流。此流已打开并准备接受输出数据。通常，此流对应于显示器输出*/InputStream in = System.in;Scanner scanner = new Scanner(in);PrintStream out = System.out;out.println("abc");//以红色打印System.err.println("我爱你");//System.out.println(1/0);//gc()// 垃圾回收JVM会自动执行,不需要人为Scanner scanner2 = new Scanner(System.in);//关闭Scanner流可以尽早回收垃圾scanner2.close();byte[] bytes = new byte[20];bytes = null; //人为置为null 也是为了让垃圾回收器及早回收//手动调用垃圾回收器回收垃圾System.gc();//exit()// 退出JVM,0正常退出,非0强制退出System.out.println("我爱你");System.out.println("我爱你");System.out.println("我爱你");System.exit(0);System.out.println("我爱你");System.out.println("我爱你");System.out.println("我爱你");System.out.println("我爱你");System.out.println(System.currentTimeMillis());//1588600069523System.out.println(System.getenv("JAVA_HOME"));//D:\develop\jdk1.8.0_161System.out.println(System.getProperty("user.dir"));//D:\IdeaProjects\20200504-晚上-博客}
}

4.BigDecimal类

A:BigDecimal的概述由于在运算的时候，float类型和double很容易丢失精度比如银行方面对数字的精确表示有严格的要求所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
B:构造方法public BigDecimal(String val)
C:成员方法public BigDecimal add(BigDecimal augend)//加public BigDecimal subtract(BigDecimal subtrahend)//减public BigDecimal multiply(BigDecimal multiplicand)//乘public BigDecimal divide(BigDecimal divisor)//除法如果能整除的话,直接除就行,如果不能整除,需要声明保留小数点后几位,不然会报异常public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)//scale 小数点后面保留几位;第一参数表示除数，第二个参数表示小数点后保留位数，第三个参数表示取舍规则。只有在作除法运算或四舍五入时才用到取舍规则。 因为BigDecimal除法可能出现不能整除的情况，比如 4.5/1.3，这时会报错java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result。所以当我们用三参数的除法方法时，规定了保留几位小数以及你的保留方式，就可以避免异常// roundingMode 取舍模式 比如四舍五入

public class MyTest4 {public static void main(String[] args) {BigDecimal bigDecimal = new BigDecimal(-10.8);System.out.println(bigDecimal);//-10.800000000000000710542735760100185871124267578125BigDecimal bigDecimal1 = new BigDecimal("8.7878241636157174183612");BigDecimal bigDecimal2 = new BigDecimal("3.13");//   public BigDecimal add(BigDecimal augend)//加System.out.println(bigDecimal.add(bigDecimal2));//public BigDecimal subtract(BigDecimal subtrahend)//减System.out.println(bigDecimal.subtract(bigDecimal2));//public BigDecimal multiply(BigDecimal multiplicand)//乘System.out.println(bigDecimal1.multiply(bigDecimal2));//public BigDecimal divide(BigDecimal divisor)//除法//public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)//scale 小数点后面保留几位//  如果能整除的话,直接除就行,如果不能整除,需要声明保留小数点后几位.BigDecimal a = new BigDecimal("2");BigDecimal b = new BigDecimal("10");System.out.println(b.divide(a));BigDecimal c = new BigDecimal("3");BigDecimal d = new BigDecimal("10");//ROUND_HALF_DOWN表示5System.out.println(d.divide(c,50,BigDecimal.ROUND_HALF_DOWN));}
}

5.Date类

A.概述:Date类:表示特定的瞬间,精确到毫秒月份由从 0 至 11 的整数表示；0 是一月、1 是二月等等；因此 11 是十二月。日期（一月中的某天）按通常方式由整数 1 至 31 表示。
B.构造方法:public Date()     创建一个代表系统当前日期的Date对象,精确到毫秒public Date(long date)     分配 Date 对象并初始化此对象,以表示自从标准基准时间（ GMT）以来的指定毫秒数。
C.成员方法:public long getTime():   获取从1970 年 1 月 1 日 00:00:00 到现在的日期日期，所间隔的毫秒值,与System.currentTimeMillis();效果相同public void setTime(long time):  给计算机元年增加相应的毫秒值

public class MyTest5 {public static void main(String[] args) {//public Date()     创建一个代表系统当前日期的Date对象,精确到毫秒Date date = new Date();System.out.println(date);//Mon May 04 22:32:48 CST 2020,重写了toString方法//Date( long date)//  分配 Date 对象并初始化此对象，以表示自从标准基准时间（ GMT）以来的指定毫秒数Date date1 = new Date(1000*60*60);System.out.println(date1);//Thu Jan 01 09:00:00 CST 1970//public long getTime():    获取从1970 年 1 月 1 日 00:00:00 到现在的日期日期，所间隔的毫秒值,//                          与System.currentTimeMillis();效果相同Date date2 = new Date();long time = date2.getTime();System.out.println(time);long l = System.currentTimeMillis();System.out.println(l);System.out.println("=================");//给计算机元年，增加相应的毫秒值,与Date的构造方法相同Date date3=new Date();date3.setTime(1000*60*10);System.out.println(date3);}
}

long与Date类型的转换

1.long--->DateA:通过构造方法B:通过setTime()方法
2.Date--->longA:getTime()方法

public class MyTest6 {public static void main(String[] args) {//long转为Date类型Date date = new Date(1000*60*60);System.out.println(date);Date date1 = new Date();date1.setTime(1000);System.out.println(date1);//Date类型转为long类型Date date2 = new Date();System.out.println(date2.getTime());}
}

注意:

使用@Deprecated注解标识的表示已过时了,不推荐使用,Date类里有大量方法已过时

6.SimpleDateFormat类

Date类打印的日期格式为西方格式,我们可以通过一个格式日期的类SimpleDateFormat，把日期变成我们想要的格式SimpleDateFormat: 可以把一个日期对象格式化成一个文本(字符串) , 也可以把一个日期字符串解析成一个日期对象构造方法:public SimpleDateFormat():使用默认的模式来创建一个SimpleDateFormat对象public SimpleDateFormat(String pattern):使用指定的模式（规则比如yyyy:MM:dd HH:mm:ss）来创建一个SimpleDateFormat对象规则的定义y              年M              月d              天H              时m              分s              秒成员方法:public String format(Date date):  把一个日期对象格式化成一个字符串public Date parse(String dateStr):  把一个日期字符串解析成一个日期对象 ,注意要以指定格式解析

public class MyTest7 {public static void main(String[] args) throws ParseException {Date date=new Date();System.out.println(date);SimpleDateFormat simpleDateFormat=new SimpleDateFormat();//格式化日期String format = simpleDateFormat.format(date);//20-5-4 下午11:05System.out.println(format);System.out.println("=======================================");//按照我们要的格式对日期进行格式化SimpleDateFormat simpleDateFormat2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");SimpleDateFormat simpleDateFormat3=new SimpleDateFormat("yyyy年MM月dd天 HH时mm分ss秒");String format2= simpleDateFormat2.format(date);System.out.println(format2);//2020-05-04 23:07:41String format3= simpleDateFormat3.format(date);System.out.println(format3);//2020年05月04天 23时10分23秒System.out.println("==============================");//public Date parse(String dateStr):   把一个日期字符串解析成一个日期对象 注意要以指定格式解析//注意：格式和日期字符串的格式要对应，负责解析失败//String--->Date解析     Date--->String格式化String str="2020年5月8日";SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy年MM月dd日");Date parse = simpleDateFormat1.parse(str);System.out.println(parse);//Fri May 08 00:00:00 CST 2020String str1="1998年7月11日";}
}

案例:计算你已经出生了多少天

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;public class MyTest8 {public static void main(String[] args) throws ParseException {Scanner sc = new Scanner(System.in);System.out.println("请输入你的生日,如1998-10-10");String str=sc.nextLine();//获取出生时的毫秒值SimpleDateFormat s = new SimpleDateFormat("yyyy-HH-dd");Date parse = s.parse(str);System.out.println(str);long time1 = parse.getTime();//获取现在的毫秒值Date date=new Date();long time2 = date.getTime();long l = (time2 - time1) / 1000;long day=l/(60*60*24);System.out.println(day);}
}

7.Calendar类

A:Calendar类的概述  Calendar 类是一个抽象类，不能直接new对象，可以通过他的一个静态成员方法getInstance()来获取他的对象,Calendar 用来替代Date类中的一些过时的方法它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。B:成员方法public static Calendar getInstance()    使用默认时区和语言环境获得一个日历对象public int get(int field)         根据常量字段，获取不同的日期public void add(int field,int amount)     根据日历的规则，为给定的日历字段添加或减去指定的时间量public final void set(int year,int month,int date)    设置日历时间 年月日

public class MyTest9 {public static void main(String[] args) {//获得Calendar的一个对象Calendar c = Calendar.getInstance();System.out.println(c);//get(int field) 根据常量字段，获取不同的日期int year = c.get(Calendar.YEAR);System.out.println(year);int month = c.get(Calendar.MONTH);System.out.println(month);int day = c.get(Calendar.DAY_OF_MONTH);System.out.println(day);int hour = c.get(Calendar.HOUR);System.out.println(hour);int minute = c.get(Calendar.MINUTE);System.out.println(minute);int second = c.get(Calendar.SECOND);System.out.println(second);Calendar c2 = Calendar.getInstance();//设置日期c2.set(Calendar.YEAR,1998);c2.set(Calendar.MONTH,11);c2.set(Calendar.DAY_OF_MONTH,19);int i = c2.get(Calendar.YEAR);System.out.println(i);System.out.println("===============");Calendar c3  = Calendar.getInstance();c3.set(1998,7,11,4,55,11);System.out.println(c3.get(Calendar.MONTH));}
}

public void add(int field,int amount)        根据日历的规则，为给定的日历字段添加或减去指定的时间量public final void set(int year,int month,int date)    设置日历时间 年月日

public class MyTest91 {public static void main(String[] args) {Calendar c = Calendar.getInstance();int i = c.get(Calendar.MONTH);System.out.println(i);c.add(Calendar.MONTH,2);System.out.println(c.get(Calendar.MONTH));//添加负数代表减法c.add(Calendar.MONTH,-3);System.out.println(c.get(Calendar.MONTH));c.add(Calendar.DAY_OF_MONTH,22);System.out.println(c.get(Calendar.DAY_OF_MONTH));}
}

案例:
键盘录入任意一个年份，获取任意一年的二月有多少天

package org.westos.demo;import java.util.Calendar;
import java.util.Scanner;public class MyTest92 {public static void main(String[] args) {//键盘录入任意一个年份，获取任意一年的二月有多少天Scanner sc = new Scanner(System.in);System.out.println("请输入年份");int year = sc.nextInt();//test(year);Calendar c = Calendar.getInstance();//设置月份为3月1号,减去一天为2月c.set(year,2,1);c.add(Calendar.DAY_OF_MONTH,-1);int day = c.get(Calendar.DAY_OF_MONTH);if (day==29){System.out.println("闰年");}else {System.out.println("平年");}}//判断输入的年份是平年还是闰年private static void test(int year) {if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {System.out.println("闰年");System.out.println("月份为29天");}else{System.out.println("平年");System.out.println("月份为28天");}}
}

8.BigInteger

获取long的最大值 long maxValue = Long.MAX_VALUE;
如果我们要使用超出long范围的数,就要使用BigInteger这个类BigInteger(String val) 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。
BigInteger(String val, int radix) 将指定基数的 BigInteger 的字符串表示形式转换为 BigInteger。

public class MyTest93 {public static void main(String[] args) {BigInteger bigInteger = new BigInteger("10000");System.out.println(bigInteger);long maxValue = Long.MAX_VALUE;BigInteger bigInteger2 = new BigInteger(maxValue+"999");System.out.println(bigInteger2);BigInteger add = bigInteger.add(bigInteger2);System.out.println(add);}
}

StringBuffer+排序+二分查找+包装类+正则表达式+常用类相关推荐

51Nod-1090 3个数和为0【排序+二分查找】
1090 3个数和为0 基准时间限制:1秒空间限制:131072KB 分值:5难度:1级算法题给出一个长度为N的无序数组,数组中的元素为整数,有正有负包括0,并互不相等.从中找出所有和 = 0的3 ...
LeetCode LCP 28. 采购方案（排序 + 二分查找）
文章目录 1. 题目 2. 解题 1. 题目小力将 N 个零件的报价存于数组 nums. 小力预算为 target,假定小力仅购买两个零件,要求购买零件的花费不超过预算,请问他有多少种采购方案. 注 ...
LeetCode 1498. 满足条件的子序列数目（排序+二分查找+快速幂）
1. 题目给你一个整数数组 nums 和一个整数 target . 请你统计并返回 nums 中能满足其最小元素与最大元素的和小于或等于 target 的非空子序列的数目. 由于答案可能很大 ...
51Nod-1001 数组中和等于K的数对【排序+二分查找】
1001 数组中和等于K的数对基准时间限制:1秒空间限制:131072KB 分值:5难度:1级算法题给出一个整数K和一个无序数组A,A的元素为N个互不相同的整数,找出数组A中所有和等于K的数对. ...
【数据结构与算法】task3 排序二分查找
排序参考:https://github.com/wangzheng0822/algo/tree/master/python 归并排序 def merge_sort(a):_merge_sort_be ...
数据结构/算法笔记（1）-两种排序二分查找
快速排序确定分界点:在数组中选一个元素的值 x x x 作为分界,(某人说)可任取 (重点)调整区间:以 x x x 为准,将数组分为左右两段,通过换位保证左边都≤x,右边都≥x,即可递归分别处理 ...
【Java】包装类正则表达式 Arrays类常见算法泛型
包装类其实就是8种基本数据类型对应的引用类型 Java为了实现一切皆对象,为了8种基本类型提供了对应的引用类型后面的集合和泛型其实也只是支持包装类型,不支持基本数据类型自动装箱: ...
【02】Java进阶：09-冒泡排序、选择排序、二分查找、异常、异常的产生和处理、自定义异常、多线程
day09[排序算法.异常.多线程基础] 今日内容冒泡排序选择排序二分查找异常处理多线程基础教学目标能够理解冒泡排序的执行原理能够理解选择排序的执行原理能够理解二分查找的执行原理能 ...
第三次学JAVA再学不好就吃翔(part59)--冒泡排序选择排序以及二分查找
学习笔记,仅供参考文章目录数组高级冒泡排序数组高级选择排序二分查找法数组高级冒泡排序冒泡排序原理:设数组中有n个元素,从第一个元素开始,对相邻元素进行两两比较,两个元素中大的往后放,第一次 ...

StringBuffer+排序+二分查找+包装类+正则表达式+常用类

一、StringBuffer

1、概述

2、构造方法

3、StringBuffer的功能

1)添加功能

2)删除功能

3)替换和反转功能

4)截取功能

3、StringBuffer类型和String类型的相互转换

4.案例

5、StringBuffer和StringBuilder的区别

6、String和StringBuffer分别作为参数传递

二、排序算法

1.冒泡排序

2.选择排序

3.直接插入排序

4.快速排序

5.希尔排序

三.二分查找

四.Arrays工具类

五.包装类

1.包装类的概述

2.Integer类的概述和构造方法

3.String类和int类的相互转换

4.JDK5的新特性：自动装箱与自动拆箱

5.面试题

6.其他包装类

五、正则表达式

1.概述

2.正则表达式的分割和替换功能

3.Pattern和Matcher

六.常用类

1.Math类

2.Random类

3.System类

4.BigDecimal类

5.Date类

long与Date类型的转换

注意:

6.SimpleDateFormat类

7.Calendar类

8.BigInteger

StringBuffer+排序+二分查找+包装类+正则表达式+常用类相关推荐

最新文章

热门文章