java基础——常用类

包装类

类结构

说明：

实现了Serallizable接口说明此类可以串行化，实现网络传输

实现了Compareable接口说明此类实例可以相互比较大小

包装类和基本数据类型的相互转换

package wrap;public class change {public static void main(String[] args) {//    包装类和基本数据类型的转换以int->integer为例int n1=100;
//    jdk5以前是手动装箱和手动拆箱//手动装箱Integer n2=Integer.valueOf(n1);//第二种手动装箱形式Integer n3=new Integer(n1);//手动拆箱int n4= n2.intValue();//jdk5以后就可以自动装箱和自动拆箱,底层执行的代码和手动装拆和手动拆箱的代码一样//自动装箱Integer n5=n1;
//        自动拆箱int n6=n5;}}

测试题

package wrap;public class wrap01_work {public static void main(String[] args) {//        下面的代码是否正确.
//        正确Double d = 100d;Float f = 1.5f;
//        如下两个题目输出结果相同吗?各是什么?
//        不相同，obj1是1.0，obj2是1
//        因为obj1赋值式子中最高精度是double所以是1.0Object obj1 = true?new Integer(1):new Double(2.0);System.out.println(obj1);//什么?Object obj2;if(true) {obj2 = new Integer(1);} else {obj2 = new Double(2.0);System.out.println(obj2);//输出什么?}}
}

包装类和string的相互转换

package wrap;public class wrap_stringchange {public static void main(String[] args) {int n1=100;//以Integer转换为string为例//        Integer->string//方式一String n2=n1+"";//方式二String n3=String.valueOf(n1);//方式三String n4=n2.toString();//string->IntegerString n5="123";
//        方式一Integer n6=Integer.parseInt(n5);//方式二Integer n7=new Integer(n5);}
}

Integer和Character类常用的方法

System.out.println(Integer.MIN_VALUE);//返回最小值
System.out.println(Integer.MAX_VALUE);//返回最大值
System.out.println(Character.isDigit('a'));//判断是不是数字
System.out.println(Character.isLetter( 'a' ));//判断是不是字母
System.out.println(Character.isUpperCase( 'a'));//判断是不是大写
System.out.println(Character.isLowerCase( 'a'));//判断是不是小写
System.out.println(Character.isWhitespace( 'a' ));//判断是不是空格
System.out.println(Character.toUpperCase( 'a'));//转成大写
System.out.println(Character.toLowerCase( 'A'));//转成小写

测试题

        //第一题Integer i = new Integer(1);Integer j = new Integer(1);System.out.println(i==j);//false;因为；两个对象不同，所以地址值不一样Integer m = 1;Integer n = 1;System.out.println(m==n);//true;
//看下面源码如果赋值-128~127直接返回，不是的话就创建对象实例//        public static Integer valueOf(int i) {//            if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
//                return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
//            return new Integer(i);
//        }Integer x = 128;Integer y = 128;System.out.println(x==y);//false;看上面原码//第二题//示例一Integer i1=new Integer( 127 );Integer i2=new Integer( 127 );System.out.println(i1==i2);//false//示例二Integer i3=new Integer( 128);Integer i4=new Integer( 128 );System.out.println(i3==i4);//false//示例三Integer i5=127;Integer i6=127;System.out.println(i5==i6);//true//示例四Integer i7=128;Integer i8=128;System.out.println(i7==i8);//false//示例五Integer i9=127;Integer i10=new Integer(127);System.out.println(i9==i10);//false//示例六Integer i11=127;int i12=127;System.out.println(i11==i12);//true；和基本数据类型比较就是数值是否相同//示例七Integer i13=128;int i14=128;System.out.println(i13==i14);//true；和基本数据类型比较就是数值是否相同

String类

String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低,因此java设计者还提供了StringBuilder 和 StringBuffer 来增强String的功能,并提高效率。

类结构

构造方法

直接赋值String s =字符串;

执行过程：先从常量池查看是否有"hsp”数据空间，如果有，直接指向;如果没有则重新创建，然后指向。S最终指向的是常量池的空间地址
调用构造器 String s2 =new String(字符串);

执行过程：先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。如果常量池没有"hsp"，重新创建,如果有，直接通过value指向。最终指向的是堆中的空间地址。

介绍

String对象用于保存字符串，也就是一组字符序列
字符串常量对象是用双引号括起的字符序列。例如:“你好”、“12.97”、"boy"等
字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节。
String类实现了

接口 Serializable 【String 可以串行化:可以在网络传输】

接口Comparable [String 对象可以比较大小]
String是final类，不能被其他的类继承
string有属性 private final char value[];用于存放字符串内容一定要注意:value是一个final类型，地址不可以修改(需要功力)
重要规则，String c1 = “ab” + “cd”;常量相加,看的是池。String c1 =+b;变量相加,是在堆中

关于String类特性的测试题

package wrap;public class String01 {public static void main(String[] args) {//第一题String a= "abc";String b = "abc";System.out.println(a.equals(b));//TrueSystem.out.println(a==b);//True//第二题String a ="hsp";String b =new String("hsp");System.out.println(a.equals(b));//trueSystem.out.println(a==b);//false//b.intern()方法最终返回的是常量池的地址(对象)System.out.println(a==b.intern());//trueSystem.out.println(b==b.intern());//false//第三题String s1 = "hspedu";String s2 ="java";String s4 = "java";String s3 = new String("java");System.out.println(s2==s3);//falseSystem.out.println(s2==s4);//trueSystem.out.println(s2.equals(s3));//trueSystem.out.println(s1==s2);//false//第四题Person p1 = new Person();p1.name = "hspedu";Person p2 = new Person();p2.name = "hspedu";System.out.println(p1.name.equals(p2.name));//trueSystem.out.println(p1.name==p2.name);//trueSystem.out.println(p1.name=="hspedu");//trueString s1 = new String("bcde");String s2 = new String("bcde");System.out.println(s1==s2);//fasle//第五题：以下语句创建了几个对象?画出内存布局图。//创建了两个对象String s1 = "hello";s1="haha";//第六题：创建了几个对象：//错误想法：创建了三个对象//解答：解释器会直接创建helloabc对象String a= "hello" +"abc";//第七题：创建了几个对象?画出内存图?//解答：创建了三个对象，但是创建c对象的时候不是和上一题一样直接指向常量池的//流程：//1.先创建一个StringBuilder sb = StringBuilder()//2.然后执行sb.append("hello");//3.sb.append("abc");//4.String c= sb.toString(//5.最后其实是 c指向堆中的对象(String) value[] -> 池中“"helloabc"，具体看图String a = "hello";String b ="abc";String c=a+b;//第八题String s1 = "hspedu";String s2 = "java";String s5 = "hspedujava";String s6 =(s1+s2).intern();System.out.println(s5==s6);//trueSystem.out.println(s5.equals(s6));//true//第九题String str = new String("hsp");final char[] ch ={'j','a','v','a'};str = "java";ch[0]='h';System.out.print(str + " and ");System.out.println(ch);//java and hava}
}
class Person{String name;
}

第五题内存布局图

第七题内存布局图

常见的方法

equals //区分大小写，判断内容是否相等
equalslgnoreCasel //忽略大小写的判断内容是否相等
length / /获取字符的个数，字符串的长度
indexOf //获取字符在字符串中第1次出现的索引,索引从O开始,如果找不到,返回-1
lastIndexOf //获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1
substring //截取指定范围的子串
trim //去前后空格
charAt :获取某索引处的字符,注意不能使用Str[index]这种方式.
toUppercase ：将字符串转换为大写
toLowercase ：将字符串转换为小写
concat ：拼接字符串
replace 替换字符串中的字符，s1.replace()返回的结果是替换过后的，对s1没有任何影响
split 分割字符串，有特殊字符，需要加上转义符 \
compareTo //比较两个字符串的大小
toCharArray //转换成字符数组
format //格式字符串，

练习实例

package wrap;public class string_method {public static void main(String[] args) {//1。equals前面已经讲过了。比较内容是否相同，区分大小写String str1 = "hello";String str2 ="Hello" ;System.out.println(str1.equals(str2));//2.equalsIgnoreCase 忽略大小写的判断内容是否相等String username = "johN" ;if("john ".equalsIgnoreCase(username)){System.out.println( "Success ! ");}else{System.out.println("Failure! ");}//3.length 获取字符的个数，字符串的长度System.out.println("hsp".length());//4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到，返回-1String s1 = "wertenweg";int index = s1.indexOf( 'w');System.out.println(index);// 0// 5.lastIndex0f 获取字符在字符串中最后一次出现的索引，索引从0开始,如果找不到,返回-1s1 = "wer@terwe@g@";index = s1.lastIndexOf('@');System.out.println(index);//11// 6.substring截取指定范围的子串String name = "hello,张三";//下面name.substring(6）从索引6开始截取后面所有的内容System.out.println(name.substring(6));//name.substring(0,5)表示从索引0开始截取,截取到5-1位置System.out.println(name.substring(0,5));//7.toUpperCase转换成大写String s = "heLLo";System.out.println(s.toUpperCase());//HELLO//8.toLowerCaseSystem.out.println(s.toLowerCase());//hello//9.concat拼接字符串String s2="宝玉";s1 = s2.concat("林黛玉").concat("薛宝钗").concat( "together");System.out.println(s1);//宝玉林黛玉薛宝骊together// 10.replace 替换字符串中的字符s1 ="宝玉 and林黛玉林黛玉林黛玉";//在s1中，将所有的林黛玉替换成薛宝钗s1 = s1.replace("林黛玉","薛宝钗");System.out.println(s1);//宝玉and薛宝骊薛宝钗薛宝骊// 11.split分割字符串，对于某些分割字符，我们需要转义比如   │   \等String poem ="锄禾日当午，汗滴禾下土,谁知盘中餐，粒粒皆辛苦";// 1.以，为标准对 poem进行分割，返回一个数组// 2.在对字符串进行分割时，如果有特殊字符，需要加入―转义符 \String[] split = poem.split("，");poem = "E: \\aaa\\bbb" ;split =poem.split("MNN");
//        String[] split = poem.split("\\\\");
//        String[] split = poem.split("\\");System.out.println("==分割后内容=== ");for (int i = 0; i< split.length; i++) {System.out.println(split[i]);}// 12.toCharArray 转换成字符数组s = "happy" ;char[] chs = s.toCharArray();for (int i = 0; i< chs.length; i++) {System.out.println(chs[i]);}// 13.compareTo比较两个字符串的大小，如果前者大，则返回正数，// 后者大，则返回负数，如果相等,返回0String a1="jchn";String b1="jabk";System.out.println(a1.compareTo(b1));//返回值是'c' - 'a' = 2的值
//        14.format格式字符串/*占位符有:*%S字符串%c字符%d 整型%.2f 浮点型**/String name1 = "john";int age = 10;double score = 98.3/3;char gender = '男';
//将所有的信息都拼接在一个字符串。String info ="我的姓名是" + name1 +"年龄是" +age + "，成绩是"+score +"性别是" + gender + "希望大家喜欢我！";System.out.println(info);//1.%s , %d , %.2f %c称为占位符//2.这些占位符由后面变量来替换//3.%s 表示后面由字符串来替换//4.%d是整数来替换//5．%.2f 表示使用小数来替换，替换后，只会保留小数点两位//6．%c使用char类型来替换String info2 = String .format("我的姓名是%s年龄是%d，成绩是%.2f性别是%c.希望大家喜欢我! ",name,age,score,gender);System.out.println(info2);}
}

StringBuffer类

基本介绍

String Buffer是一个容器。
java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。
很多方法与String相同，但StringBuffer是可变长度的。

类结构

String Vs StringBuffer

String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低//private final char valuell;
StringBuffer保存的是字符串变量,里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用更新地址,效率较高/char[ value;1/这个放在堆.

构造方法

stringBuffer()构造一个其中不带字符的字符串缓冲区，其初始容量为16个字符。
stringBuffer(CharSequence seq)构造一个字符串缓冲区，它包含与指定的charSequence相同的字符。
StringBuffer(int capacity) 构造一个不带字符，但具有指定初始容量的字符串缓冲区。即对char[]大小进行指定
StringBuffer(String str)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。大小为，字符串长度+16

String和StringBuffer相互转换

package wrap;public class StringBuffer01{public static void main(String[] args) {//String-->StringBufferString s= "hello";//方式1://返回的才是StringBuffer对象，对str本身没有影响StringBuffer b1=new StringBuffer(s);//方式2:StringBuffer b2 = new StringBuffer();b2.append(s);//StringBuffer->String//方式1:String s2 = b1.toString();//方式2:String s3 = new String(b1);}
}

常用的方法

package wrap;public class StringBuffer02 {public static void main(String[] args) {StringBuffer s = new StringBuffer("hello");//增s.append('.');s.append("张三丰");s.append("赵敏").append(100).append(true).append(10.5);System.out.println(s);//hello,张三丰赵敏100true10.5// 删/*删除索引为>=start && <end处的字符解读:删除11~14的字符[11，14)*/s.delete(11,14);System.out.println(s);//改s.replace(9,11,"周芷若");System.out.println(s);//查找指定的子串在字符串第一次出现的索引，如果找不到返回-1int indexOf = s.indexOf("张三丰");System.out.println(indexOf);//hello.张三丰周芷若true10.5s.insert(9,"赵敏");System.out.println(s);//长度System.out.println(s.length());System.out.println(s);}
}

练习题

package wrap;public class StringBufferwork01 {public static void main(String[] args) {//第一题：看下面的代码输出什么?为什么?String str = null;StringBuffer sb = new StringBuffer();sb.append(str);System.out.println(sb.length());//4 -> 解读：sb.append(str)底层调用的是 AbstractStringBuilder的 appendNull，赋值为4，内容为nullSystem.out.println(sb);//nullStringBuffer sb1 = new StringBuffer(str);System.out.println(sb1);//报错 -> 解读：StringBuffer sb1 = new StringBuffer(str)的底层源码super(str.length0 + 16);//第二题：输入商品名称和商品价格，要求打印效果示例，使用前面学习的方法完成:// 商品名  商品价格//  手机  123,564.59//要求:价格的小数点前面每三位用逗号隔开，在输出。//思路分析//1。定义一个Scanner对象，接收用户输入的价格(String)//2．希望使用到StringBuffer的 insert ，需要将String 转成StringBuffer//3.然后使用相关方法进行字符串的处理//代码实现Scanner input=new Scanner(System.in);System.out.print("请输入商品的名字：");String name=input.next();System.out.print("情输入商品的价格：");StringBuffer price=new StringBuffer(input.next());if (price.lastIndexOf(".")>0) {for (int i = price.lastIndexOf(".") - 3; i > 0; i -= 3) {price.insert(i, ",");}}else{for (int i = price.length() - 3; i > 0; i -= 3) {price.insert(i, ",");}}System.out.println("商品\t商品名\n"+name+"\t"+price);}
}

StringBuilder类

基本介绍

一个可变的字符序列。此类提供一个与 StringBuffer 兼容的API,但不保证同步(StringBuilder不是线程安全)。该类被设计用作 StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能,建议优先采用该类因为在大多数实现中，它比 StringBuffer 要快。
在StringBuilder上的主要操作是 append 和 insert方法,可重载这些方法,以接受任意类型的数据。

常用方法

StringBuilder 和 StringBuffer 均代表可变的字符序列，方法是一样的，所以使用和StringBuffer一样.

知识点总结

StringBuilder继承 AbstractStringBuilder类
实现了Serializable ，说明StringBuilder对象是可以串行化(对象可以网络传输,可以保存到文件)StringBuilder是final类，不能被继承
StringBuilder对象字符序列仍然是存放在其父类AbstractStringBuilder的 char[] value;因此，字符序列是堆中
StringBuilder 的方法，没有做互斥的处理,即没有synchronized关键字,因此在单线程的情况下使用StringBuilder

String,StringBuffer 和StringBuilder的比较

StringBuilder 和 StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
String:不可变字符序列,效率低,但是复用率高。
StringBuffer:可变字符序列、效率较高(增删)、线程安全
StringBuilder:可变字符序列、效率最高、线程不安全
String使用注意说明:
1. string s=“a”;//创建了一个字符串
2. s += “b”;//实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串s+“b”(也就是"ab”)。如果多次执行这些改变串内容的操作,会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能=>结论:如果我们对String 做大量修改,不要使用String
效率:StringBuilder > StringBuffer > String

String,StringBuffer和StringBuilder的选择

如果字符串存在大量的修改操作，一般使用 StringBuffer 或StringBuilder
如果字符串存在大量的修改操作,并在单线程的情况,使用 StringBuilder
如果字符串存在大量的修改操作,并在多线程的情况,使用 StringBuffer
如果我们字符串很少修改，被多个对象引用，使用String,比如配置信息等

Math类

基本介绍

Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。math类的方法一般都为静态方法，直接调用即可。

常用方法

package wrap;public class math01 {public static void main(String[] args) {//1.abs 绝对值int abs = Math.abs(-9);System.out.println(abs);//2.pow求幂double pow = Math.pow(2,4);//2的4次方// System.out.println(pow); //16//3.ceil向上取整,返回>=该参数的最小整数(double);double ceil = Math.ceil(-3.0001);System.out.println(ceil);//4.floor向下取整，返回<=该参数的最大整数(double);double floor = Math.floor(-4.999);System.out.println(floor);//5.round 四舍五入 Math.floor(该参数+0.5)long round = Math.round(-5.001);System.out.println(round);//6.sqrt求开方double sqrt = Math.sqrt(-9.0);System.out.println(sqrt);//7.random返回的是0<= x<1之间的一个随机小数//思考:请写出获取 a-b之间的一个随机整数,a, b均为整数，比如 a = 2，b=7// 即返回一个数x2 <= x <= 7//老韩解读//      (1)(int)(a) <= x <= (int)(a + Math.random() * (b-a +1) )int a=1,b=2;for(int i = 0; i< 10; i++) {System.out.println((int)(a+ Math.random()*(b-a +1)));}}
}

Arrays类

Arrays里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)。

常用方法

package wrap;import java.util.Arrays;
import java.util.Comparator;
import java.util.List;public class Arrays01 {public static void main(String[] args) {Integer[] integers = {1,20,90};//遍历数组for(int i = 0; i< integers.length; i++) {System.out.println(integers[i]);}//直接使用Arrays.toString方法，显示数组System.out.println(Arrays.toString(integers));//演示sort方法的使用Integer arr[]={-1,7,0,89};//进行排序//1．可以直接使用冒泡排序，也可以直接使用Arrays提供的sort方法排序//2．因为数组是引用类型，所以通过sort排序后，会直接影响到实参arr// 3. sort重载的，也可以通过传入一个接口 Comparator实现定制排序//4．调用定制排序时，传入两个参数// (1)排序的数组arr//(2〕实现了Comparator接口的匿名内部类，要求实现compare方法//5先演示效果，再解释//6原码分析//(1)Arrays.sort(arr, new Comparator(//(2）最终到 TimSort类的 private static <T> void binarySort(T[] a, int lo//Comparator<? super T> c))//(3）执行到 binarySort方法的代码，会根据动态绑定机制c.compare()执行我们传入//      匿名内部类的 compare (//while (left < right) {//                  int mid = (left + right) >>> 1;//                  if (c.compare(pivot,a[mid])<0)//                      right = mid;//                  else//                      left = mid + 1;//                  }//(4)public int compare(0bject o1,0bject o2)返回的值>0还是<O会影响整个排序结果Arrays.sort(arr, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return 0;}});//binarySearch通过二分搜索法进行查找，要求必须排好//1．使用binarySearch二叉查找//2．要求该数组是有序的．如果该数组是无序的，不能使用binarySearch//3.如果数组中不存在该元素,就返回return -(low +1) low指的是应该在的位置Integer[] arr1 = {12,90,123,567};int index = Arrays.binarySearch(arr1,12);System.out.println( "index=" + index) ;//copyOf数组元素的复制=//1．从arr数组中，拷贝arr.length个元素到newArr数组中// 2．如果拷贝的长度> arr.length就在新数组的后面增加null// 3．如果拷贝长度<0就抛出异常NegativeArraySizeExceptionInteger[] newArr = Arrays.copyOf(arr1,arr1.length);System.out.println("==拷贝执行完毕后==");System.out.println(Arrays.toString(newArr));//fill填充数组Integer[] num = new Integer[]{9,3,2};//1．使用99去填充num数组，可以理解成是替换原理的元素Arrays.fill(num,99);System.out.println("==num数组填充后==");System.out.println(Arrays.toString(num));//equals比较两个数组元素内容是否完全一致Integer[] arr2 = {1,2,90,123};//1．如果arr 和arr2数组的元素一样，则方法true;// 2。如果不是完全一样，就返回 falseboolean equals = Arrays.equals(arr,arr2);System.out.println("equals=" +equals);//1. asList方法，会将(2,3,4,5,6,1)数据转成一个List集合//2．返回的 asList 编译类型List(接口)//3. asList运行类型java.util.Array#ArrayListList asList = Arrays.asList(2,3,4,5,6,1);System.out.println("asList=" +asList);System.out.println("asList的运行类型" +asList.getClass());}
}

练习题

package wrap;import java.util.Arrays;
import java.util.Comparator;public class arrays_work {public static void main(String[] args) {//        案例:自定义Book类，里面包含name和price,按price排序(从大到小)。
//        要求使用两种方式排序，有一个 Book[]数组,里面有4个book对象.
//        使用前面学习过的传递实现Comparator接口匿名内部类,也称为定制排序。
//        可以按照price (1)从大到小(2)从小到大
//         (3)按照书名长度从大到小Book[] books = new Book[4];books[0] = new Book("红楼梦", 100);books[1] = new Book("金瓶梅新",90);books[2] = new Book("青年文摘20年", 5);books[3]= new Book("java从入门到放弃~",300);
//        按照price 从小到大Arrays.sort(books, new Comparator<Book>() {@Overridepublic int compare(Book o1, Book o2) {Book book01=(Book)o1;Book book02=(Book)o2;double price=book01.price- book02.price;if (price>0){return 1;}else if (price<0){return -1;}else{return 0;}}});System.out.println(Arrays.toString(books));
//        按照price从大到小Arrays.sort(books, new Comparator<Book>() {@Overridepublic int compare(Book o1, Book o2) {Book book01=(Book)o1;Book book02=(Book)o2;double price=book01.price- book02.price;if (price>0){return -1;}else if (price<0){return 1;}else{return 0;}}});System.out.println(Arrays.toString(books));//按照书名长度从大到小Arrays.sort(books, new Comparator<Book>() {@Overridepublic int compare(Book o1, Book o2) {Book book01=(Book)o1;Book book02=(Book)o2;return book02.name.length()- book01.name.length();}});System.out.println(Arrays.toString(books));}
}
class Book{String name;double price;public Book(String name, double price) {this.name = name;this.price = price;}@Overridepublic String toString() {return "Book{" +"name='" + name + '\'' +", price=" + price +'}';}
}

System类

常见方法

package wrap;import java.util.Arrays;public class system01 {public static void main(String[] args) {//exit退出当前程序System.out. println("ok1");//1. exit(0)表示程序退出//2．0表示一个状态，正常的状态System.exit(0);System.out. println("ok1");//arraycopy :复制数组元素，比较适合底层调用，//一般使用Arrays.copyOf完成复制数组int[] src={1,2,3};int[] dest = new int[3];//dest当前是 {0,0,0}//1．主要是搞清楚这五个参数的含义//2.
//           源数组
//           *@param      src     the source array.
//           srcPos:从源数组的哪个索引位置开始拷贝
//           *@param      srcPos  starting position in the source array.
//           dest :目标数组，即把源数组的数据拷贝到哪个数组
//           *@param       dest    the destination array.
//           destPos:把源数组的数据拷贝到目标数组的哪个索引
//           *@param      destPos  starting position in the destination data.
//           length:从源数组拷贝多少个数据到目标数组
//          *@param       length    the number of array elements to be copied.System.arraycopy(src,0,dest,0,3);System.out.println("dest=" + Arrays.toString(dest));//currentTimeMillens:返回当前时间距离1970-1-1 的毫秒数System.out.println(System.currentTimeMillis());}
}

Biglnteger和BigDecimal类

应用场景:

Biglnteger适合保存比较大的整型
BigDecimal适合保存精度更高的浮点型(小数）

使用说明

biginteger

package wrap;import java.math.BigInteger;public class biginteger01 {public static void main(String[] args) {///当我们编程中，需要处理很大的整数，long 不够用// 可以使用BigInteger的类来搞定
//        long l = 23788888899999999999999999999l;//报错下面代码解决
//        System.out.println("l="+l);BigInteger bigInteger = new BigInteger("2378888889999999999999999999p");BigInteger bigInteger2 = new BigInteger("100");System.out.println(bigInteger);//1.在对 BigInteger进行加减乘除的时候，需要使用对应的方法，不能直接进行+– */////2。可以创建一个要操作的 BigInteger 然后进行相应操作BigInteger add = bigInteger.add(bigInteger2);System.out.println(add);//加BigInteger subtract = bigInteger.subtract(bigInteger2);System.out.println(subtract);//减BigInteger multiply = bigInteger.multiply(bigInteger2);System.out.println(multiply);//乘BigInteger divide = bigInteger.divide(bigInteger2);System.out.println(divide);//除}
}

bigdecimal

package wrap;import java.math.BigDecimal;public class bigdecimal {public static void main(String[] args) {//当我们需要保存一个精度很高的数时，double不够用// 可以是 BigDecimaldouble d = 1999.111111311119999999999999999999999999999999999999999999999999999999999999999977788d;//不会报错，但是精度不够System.out.println(d);BigDecimal bigDecimal = new BigDecimal( "1999.111111111111111111111999999999999977788");BigDecimal bigDecimal2 = new BigDecimal( "1.1");System.out.println(bigDecimal);//1。如果对 BigDecimal进行运算，比如加减乘除，需要使用对应的方法// 2。创建一个需要操作的 BigDecimal然后调用相应的方法即可System.out.println(bigDecimal.add(bigDecimal));System.out.println(bigDecimal.subtract(bigDecimal2));System.out.println(bigDecimal.multiply(bigDecimal2));System.out.println(bigDecimal.divide(bigDecimal2));// 可能抛出异常ArithmeticException,因为除不尽，出现了无限循环小数// 在调用divide 方法时，指定精度即可。System.out.println(bigDecimal.divide(bigDecimal2,BigDecimal.ROUND_CEILING));}
}

日期类

第一代日期类：Date类

精确到毫秒，代表特定的瞬间

类结构

SimpleDateFormat

格式和解析日期的类SimpleDateFormat格式化和解析日期的具体类。它允许进行格式化(日期->文本)、解析(文本->日期)和规范化.

应用实例

package wrap;import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;public class Date01 {public static void main(String[] args) throws ParseException {Date d1 = new Date();//获取当前系统时间System.out.println("当前的日期是"+d1);//1．获取当前系统时间//2．这里的Date类是在java.util包//3．默认输出的日期格式是国外的方式，因此通常需要对格式进行转换Date d2 = new Date(9234567);//通过指定毫秒数得到时间System.out.println(d2.getTime());//获取某个时间对应的毫秒数SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");//1．创建SimpleDateFormat对象，可以指定相应的格式// 2．这里的格式使用的字母是规定好，不能乱写String format = sdf.format(d1); // format:将日期转换成指定格式的字符串System.out.println("当前的日期是"+format);//1．可以把一个格式化的String转成对应的DateString s = "1996年01月01日 10:20:30 星期一";Date parse = sdf.parse(s);//将异常抛出去即可System.out.println("日期"+parse);}
}

第二代日期类

calendar类

Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法,并为操作日历字段（例如获得下星期的日期)提供了一些方法。

类结构

应用实例

package wrap;import java.util.Calendar;public class calendar01 {public static void main(String[] args) {//1. Calendar是一个抽象类，并且构造器是private// 2．可以通过getInstance()来获取实例//3．提供大量的方法和字段提供给程序员Calendar c= Calendar.getInstance();//创建日历类对象,比较简单，自由System.out.println(c);//获取日历对象的某个日历字段System.out.println("年:"+c.get(Calendar.YEAR));//这里为什么要＋1，因为Calendar返回月时候，是按照0开始编号System.out.println("月:"+(c.get(Calendar.MONTH)+1));System.out.println("日:"+c.get(Calendar.DAY_OF_MONTH));//5．如果我们需要按照、24小时进制来获取时间，Calendar . HOUR-=改成=> Calendar .HOUR_OF_DAYSystem.out.println("小时:"+c.get(Calendar.HOUR));System.out.println("分钟:"+c.get(Calendar.MINUTE));System.out.println("秒:"+c.get(Calendar.SECOND));//Calender没有专门的格式化方法，所以需要程序员自己来组合显示System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"+c.get(Calendar.DAY_OF_MONTH)+"日");}
}

第三代日期类

Calendar问题分析

可变性:像日期和时间这样的类应该是不可变的。
偏移性:Date中的年份是从1900开始的,而月份都从0开始。格式化:格式化只对Date有用，Calendar则不行。
此外，它们也不是线程安全的;不能处理闰秒等(每隔2天,多出1s)。

Local类

LocalDate只包含日期，可以获取日期字段
LocalTime只包含时间,可以获取时间字段
LocalDateTime包含日期+时间，可以获取日期和时间字段

类结构

DateTimeFormatter类

格式日期类类似于SimpleDateFormat类

使用方法

DateTimeFormat dtf = DateTimeFormatter.ofPattern(格式);

String str = dtf.format(日期对象);

应用实例

package wrap;import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;public class loacl {public static void main(String[] args) {//1。使用now()返回表示当前日期时间的对象LocalDateTime ldt = LocalDateTime.now();//LocalDate.now();// LocalTime.now()System.out.println(ldt);System.out.println("年=" + ldt.getYear());System.out.println("月非" + ldt.getMonth());System.out.println( "月=" + ldt.getMonthValue());System.out.println("日=" +ldt.getDayOfMonth());System.out.println("时于" + ldt.getHour());System.out.println("分=" + ldt.getMinute());System.out.println("秒=" + ldt.getSecond());LocalDate now = LocalDate.now();//可以获取年月日LocalTime now2 = LocalTime.now();//获取到时分秒}
}

Instant时间戳

类似于Date提供了一系列和Date类转换的方式

Instant—>Date:
Date date = Date.from(instant);
Date->Instant:
lnstant instant = date.tolnstant(;

应用实例

package wrap;import java.time.Instant;
import java.util.Date;public class instant {public static void main(String[] args) {//1.通过静态方法 now()获取表示当前时间藏的对象Instant now = Instant.now();System.out.println(now);//2．通过 from 可以把 Instant转成DateDate Date date = Date.from(now);//3．通过 date的toInstant()可以把 date 转成Instant对象Instant instant = date.toInstant();}
}

练习题

package wrap;public class wrapwork {public static void main(String[] args) {     1.编程题
      (1)将字符串中指定部分进行反转。比如将"abcdef"反转为"aedcbf"
      (2)编写方法public static String reverse(String str, int start , int end）搞定
//        String str="abcdef";
//        str=reverse(str,0,2);
//        System.out.println(str);
     2.输入用户名、密码、邮箱，如果信息录入正确，则提示注册成功，否则生成异常对象
       要求:
//    //      (1)用户名长度为2或3或4
//    //      (2)密码的长度为6，要求全是数字'123456'
//    //      (3)邮箱中包含@和.并且@在.的前面isDigital
//        String secret="222222";
//        String box="sadas@sdfs.com";
//        str=checkinfo(str,secret,box);
//        System.out.println(str);
     3.编写java程序，输入形式为:
          Han Shun Ping的人名，以Ping,Han.S的形式打印 出来。
          其中.S是中间单词的首字母。
     (2)例如输入“Willian Jefferson Clinton”，输出形式为:
          Clinton,Willian .J
//        String name="Willian Jefferson Clinton";
//        printname(name);
    4.输入字符串，判断里面有多少个大写字母，多少个小写字母，多少个数字
//        numchar(name);
//     5.写出一下运行结果：String s1="abcedfsd";Animal a = new Animal(s1);Animal b = new Animal(s1);System.out.println(a==b);//falseSystem.out.println(a.equals(b));//falseSystem.out.println(a.name==b.name);//trueString s4= new String("abcedfsd");String s5 = "abcedfsd";System.out.println(s1==s4);//falseSystem.out.println(s4==s5);//falseString t1 = "hello"+s1;String t2 = "helloabcedfsd";System.out.println(t1.intern()==t2);//true 解读：intern()方法最终返回的是常量池的地址(对象)}public static String reverse(String str, int start , int end){if (str==null||start<0||end<=start||end>=str.length()){System.out.println("输入格式有误,反转失败！");return str;}char[] list= str.toCharArray();char temp=' ';for (int i =start,j=end ; i!=j; i++,j--) {temp=list[i];list[i]=list[j];list[j]=temp;}return new String(list);}public static String checkinfo(String name,String  secret,String box){if (name==null||secret==null||box==null){return "输入信息不能为空！";}if (name.length()<2||name.length()>4){return "用户名长度为2-4!";}if (secret.length()!=6){return "密码的长度应设置为6位！";}for (int i = 0; i <secret.length() ; i++) {if (secret.charAt(i)>'9'||secret.charAt(i)<'0'){return "密码必须全部是数字！";}}int i=box.indexOf("@");int j=box.indexOf(".");if (i<0){return "邮箱中必须有@字符";}else if(j<0){return "邮箱中必须有 . 字符！";}else if (j<=i){return "@应该在.的前面";}return " 注册成功！";}public static void printname(String name){String[] names=name.split(" ");if (names.length!=3){System.out.println("输入格式有误！");}else{System.out.println(names[2]+","+names[0]+" ."+names[1].toUpperCase().charAt(0));}}public static void numchar(String str){int[] num=new int[3];for (int i = 0; i <str.length() ; i++) {if (str.charAt(i)>'0'&&str.charAt(i)<'9'){num[0]++;}else if (str.charAt(i)>'a'&&str.charAt(i)<'z'){num[1]++;}else if (str.charAt(i)>'A'&&str.charAt(i)<'Z'){num[2]++;}}System.out.println("数字的数量是"+num[0]+"\n小写字母的数量是"+num[1]+"\n大写字母的数量是"+num[2]);}
}
class Animal {String name;public Animal(String name){this.name= name;}
}