如何建设网站功能设计,通用cms网站,杭州网站建设网站,到哪里找人做网站java一些精干知识点分享 2. java小干货2.1循环遍历2.2可变参数2.3 list和数组转化2.3.1 数组转list2.3.2 list转数组 2.4 值传递和地址传递2.4.1值传递2.4.2 地址传递2.4.3易错点总结 2.5 数据类型2.5.1基础知识2.5.2 基础数据和包装类 2.6 字符串2.6.1 char/String区别2.6.2 .… java一些精干知识点分享 2. java小干货2.1循环遍历2.2可变参数2.3 list和数组转化2.3.1 数组转list2.3.2 list转数组 2.4 值传递和地址传递2.4.1值传递2.4.2 地址传递2.4.3易错点总结 2.5 数据类型2.5.1基础知识2.5.2 基础数据和包装类 2.6 字符串2.6.1 char/String区别2.6.2 .关于String的创建方式2.6.3 String StringBuffer StringBuild区别 2.7数组2.7.1 数组定义2.7.2 数组帮助类Arrays2.7.3 Apache Commons Lang3 2.8 equals和、compareTo区别2.8.1 和equals2.8.2 compareTo 2.9代码块、内部类和匿名类2.9.1代码块2.9.2内部类2.9.3匿名类 2.10枚举2.11 集合2.12 日期类LocalDate2.13 java泛型及通配符2.14文件流IO 2. java小干货
2.1循环遍历
数组、list、map都需要遍历循环有下面集中循环方式 1.for ecah list可以是一个数组、list、set
// list可以是一个数组、list、set
for(bject o :list) {}2.Iterator迭代器 list可以是list、set类的子类
Iterator iter list.iterator();while(iter.hasNext()){Object o iter.next();}3.loop with size 可以是数组、list能得到索引长度的类及子类
for(int i0;ilist.size();i){Object o list.get(i);}4.lambda表达式 list.forEach((value)-{System.out.println(value);});代码示例
public class GanHuo {Testpublic void t1(){//1.for-each遍历最简单,但无法获得索引System.out.println(for(Object:list)循环);String arrayStr[]new String[]{1,2,3};//1-1 数组System.out.println(for-each遍历数组-----------);for (String s : arrayStr) {System.out.println(arrayStr:s);}//1-2 listListInteger list Arrays.asList(1,2,3,4);System.out.println(for-each遍历list-----------);for (Integer i : list) {System.out.println(list:i);}//1-3 遍历mapMapString,String mapnew HashMap();System.out.println(for-each遍历Map-----------);map.put(1, 111);map.put(2, 222);map.put(3, 222);//得到key的collectonSetString keySetmap.keySet();for(String key:keySet){System.out.println(map[key]map.get(key));}}Testpublic void t2(){System.out.println(Iterator循环);//1-2 listListInteger list Arrays.asList(1,2,3,4);System.out.println(Iterator 遍历list-----------);Iterator iterlist.iterator();while (iter.hasNext()) {System.out.println(list:iter.next());}//1-3 遍历mapMapString,String mapnew HashMap();System.out.println(Iterator 遍历Map-----------);map.put(1, 111);map.put(2, 222);map.put(3, 222);//得到key的collectonSetString keySetmap.keySet();iterkeySet.iterator();while (iter.hasNext()) {String key (String) iter.next();System.out.println(map[key]map.get(key));}}Testpublic void t3(){System.out.println(for。size循环);//1-1 数组String arrayStr[]new String[]{1,2,3};System.out.println(loop size 遍历数组-----------);for (int i 0; i arrayStr.length; i) {System.out.println(arrayStr[i]arrayStr[i]);}//1-2 listListInteger list Arrays.asList(1,2,3,4);System.out.println(loop size 遍历list-----------);for (int i 0; i list.size(); i) {System.out.println(list[i]list.get(i));}}Testpublic void t4(){System.out.println(lambda表达式);//list的lambda表达式ListInteger list Arrays.asList(1,2,3,4);System.out.println(lambda表达式 遍历list-----------);list.forEach((value)-{System.out.println(value);});//Map的lambda表达式MapString,String mapnew HashMap();System.out.println(lambda表达式 遍历Map-----------);map.put(1, 111);map.put(2, 222);map.put(3, 222);map.forEach((key, value)-{System.out.print(key key);System.out.println(, value value);});}}2.2可变参数
可变参数是指不指定参数的个数 定义 数据类型… 变量名 可变参数规范 1.可变参数本身是一个数组 2.可变参数也可传递一个数组 3.可变参数个数不受限制可无限制也可没有 4.如果可变参数和常规参数混合则可变参数要放到最后 5.每个方法最多只能有一个可变参数 代码示例 public class ChangeParam {public void param(Integer... val){System.out.println(val包含val.length个参数);for (Integer i : val) {System.out.println(i);}}/***如果一个方法里包含常规参数和可变参数则可变参数必须放置到最后一个*/public void param1(String name,Integer age,String... likes){System.out.println(name:name);System.out.println(age:age);System.out.println(likes-----);String temp;for (String like : likes) {templike,;}System.out.println(temp);}Testpublic void t1(){//可以传递不受限制的个数param(1,2,3);//可以不传参数param();//也可传递数组Integer[] array{1,2,3};param(array);//常规和可变参数混合param1(蒋增奎,20,火锅,串串,烤鸭);}
}
2.3 list和数组转化
2.3.1 数组转list 1.使用ListArrays.asList(数组对象)最简单但不能新增删除 2.Listnew ArrayList(Arrays.asList(intArray)),可新增删除但性能差 3. Collections.addAll(list对象, 数组对象);可新增删除性能好 4.list Stream.of(数组对象).collect(Collectors.toList()); Testpublic void array2List(){System.out.println(Arrays.asList);//1---直接用Arrays.asList后不能再新增System.out.println(1---直接用Arrays.asList后不能再新增);//基本类型数组Integer[] intArray{1,2,3};ListObject list1 Arrays.asList(intArray);// list1.add(4); //不能再新增否则要报异常printList(list1);//自定义数组TestVO[] objArray{new TestVO(1,jzk),new TestVO(2,张三)};list1Arrays.asList(objArray);printList(list1);//2--Arrays.asList作为构造参数传入可新增但性能差System.out.println(2--Arrays.asList作为构造参数传入可新增但性能差);list1new ArrayList(Arrays.asList(intArray));list1.add(4);printList(list1);//3--Collections.addAll(list,数组);能新增删除性能好System.out.println(3--Collections.addAll(list,数组);能新增删除性能好);list1new ArrayList();Collections.addAll(list1, intArray);list1.add(4);printList(list1);//4--使用 Stream;能新增删除性能好System.out.println(4--使用 Stream;能新增删除性能好);list1 Stream.of(intArray).collect(Collectors.toList());list1.add(4);printList(list1);}private void printList(ListObject list){for (Object o : list) {System.out.println(o);}}2.3.2 list转数组 核心用到list.toArray()方法 1.Object[] arrayslist.toArray(); 只能获得Object数组 2.对象数组list.toArray(new 对象[list.size] ) ;//可以获得对应的对象数组 测试代码
Testpublic void list2array(){ListTestVO listgetTestVO();System.out.println(方法1list.toArray());//注意只能用转换成Object[]数组不能强制转化Object[] arrayslist.toArray();for (Object array : arrays) {System.out.println((TestVO)array);}System.out.println(方法2list.toArray(数组对象));//这样可获得实际的类TestVO[] vosnew TestVO[list.size()];list.toArray(vos );for (TestVO vo : vos) {System.out.println(vo);}//或者这样写System.out.println(方法3list.toArray(数组对象)简写);voslist.toArray(new TestVO[list.size()]);for (TestVO vo : vos) {System.out.println(vo);}System.out.println(方法4String[] strings list.stream().toArray(String[]::new););TestVO[] vos2list.stream().toArray( TestVO[]::new);for (TestVO vo : vos2) {System.out.println(vo);}}private void printList(ListObject list){for (Object o : list) {System.out.println(o);}}private ListTestVO getTestVO(){ListTestVO listnew ArrayList();list.add(new TestVO(1,jzk));list.add(new TestVO(2,张三));return list;}2.4 值传递和地址传递
在学习 Java 编程语言的过程中我们经常会听到“值传递”和“地址传递”这两个概念。它们是用来描述参数传递方式的术语而理解它们的区别对于编写高效的代码非常重要。在本文中我们将详细介绍这两种传递方式并通过代码示例来说明它们的差异。
2.4.1值传递
在 Java 中基本数据类型如整数、布尔值等都是以值传递的方式进行参数传递。这意味着当我们将一个基本数据类型作为参数传递给一个方法时方法内部会创建一个新的变量来存储这个参数的值而不会影响原始的变量。 执行过程 首先在调用方法时将实际参数的值复制一份并将这份副本传递给方法进行操作。在方法内部这个副本的值被赋给一个新的局部变量。在方法执行过程中对该局部变量的任何改动都不会影响原始的变量因为它们指向的是不同的内存空间。当方法执行完毕后这个局部变量和方法的栈帧都会被销毁而原始的变量的值保持不变。
基本数据类型的传递过程中传入的值被复制到方法内部并在方法内部进行操作但不会影响原始变量的值。
Testpublic void valPass(){String stra;double db Double.parseDouble(34.5);Double db145.2;Integer zsInteger.valueOf(100);int zs1200;boolean bfalse;Boolean b1 true;System.out.println(strstr);System.out.println(dbdb);System.out.println(db1db1);System.out.println(zszs);System.out.println(zs1zs1);System.out.println(bb);System.out.println(b1b1);change1(str,db,db1,zs,zs1);System.out.println(strstr);System.out.println(dbdb);System.out.println(db1db1);System.out.println(zszs);System.out.println(zs1zs1);}private void change1(String str,double db,Double db1,int zs,Integer zs1){System.out.println(change);strb;db-45.2;db1-22.4;zs-1;zs1-2;}执行效果可以看出这些都是值传递被引用后并没有改变以前值
stra
db34.5
db145.2
zs100
zs1200
bfalse
b1true
change
stra
db34.5
db145.2
zs100
zs1200
2.4.2 地址传递
与基本数据类型不同Java 中的对象类型如数组、集合、自定义类等则是以地址传递的方式进行参数传递。这意味着当我们将一个对象作为参数传递给一个方法时方法内部使用的是这个对象的引用而不是对象本身。 执行过程 创建一个对象并将其引用赋值给一个变量。 将这个变量作为参数传递给一个方法。 在方法内部参数变量接收到了对原始对象的引用。 在方法内部修改参数变量所指向的对象时原始对象也会受到影响。 方法执行完毕后返回到原始调用处可以通过原始变量访问到被修改后的对象。
对象的引用传递意味着传递的是对象的引用通过引用可以访问和修改原始对象的属性。
测试代码 Testpublic void addressPass(){StringBuffer sbnew StringBuffer(aa);TestVO vonew TestVO(1,蒋增奎);String[] array{1,2,3};ListInteger listnew ArrayList();list.add(1);list.add(2);MapString,Integer mapnew HashMap();map.put(1, 11);map.put(2, 22);System.out.println(sb:sb);System.out.println(vo:vo);System.out.println(array: Arrays.toString(array));System.out.println(list:Arrays.toString(list.toArray()));System.out.println(map:map.toString());System.out.println();change2(sb,vo,array,list,map);System.out.println(sb:sb);System.out.println(vo:vo);System.out.println(array: Arrays.toString(array));System.out.println(list:Arrays.toString(list.toArray()));System.out.println(map:map.toString());}private void change2( StringBuffer sb, TestVO vo,String[] array,ListInteger list,MapString,Integer map){sb.append(dd);vo.setName(蒋大爷);array[0]改值11;list.add(3);map.put(3,333);}效果地址引用值都会被改变
sb:aa
vo:TestVO(id1, name蒋增奎)
array:[1, 2, 3]
list:[1, 2]
map:{111, 222}sb:aadd
vo:TestVO(id1, name蒋大爷)
array:[改值11, 2, 3]
list:[1, 2, 3]
map:{111, 222, 3333}代码2 Testpublic void t2() {TestVO vo1new TestVO(1, jzk);TestVO vo2vo1;vo2.setName(奎哥);System.out.println(vo1); //打印TestVO(id1, name奎哥)不是jzkSystem.out.println(vo2);//TestVO(id1, name奎哥)}首先创建一个对象TestVO vo1接着申请另一款空间用来创建TestVO vo2且vo2vo1说明两个数组都指向同一块空间修改vo2中的字段也就相当于修改了vo1中对应的元素。
代码3
Testpublic void t1(){TestVO vonew TestVO(1, jzk);System.out.println(vo);change3(vo);System.out.println(vo);change4(vo);System.out.println(vo);}private void change3(TestVO vo){TestVO vo1vo; //把vo赋值给vo1,两个对象是指向同一个地址vo1.setName(奎哥);}private void change4(TestVO vo){vo.setName(鸡哥);}打印效果
TestVO(id1, namejzk)
TestVO(id1, name奎哥)
TestVO(id1, name鸡哥)代码说明 change3()和change4()效果一样change3()虽然通过了赋值但两个对象指向的同一个地址
2.4.3易错点总结
易错点 java对象String ,int等对应的封装类Integerjava.util.Date,BigDecimal是值传递不是地址传递虽然他们是对象
值传递VS地址传递 2.5 数据类型
2.5.1基础知识
Java基本类型共有八种基本类型可以分为三类字符类型char布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的它们的取值范围是固定的不会随着机器硬件环境或者操作系统的改变而改变。实际上JAVA中还存在另外一种基本类型void它也有对应的包装类 java.lang.Void不过我们无法直接对它们进行操作 代码说明 //基础数据类型Testpublic void t1(){//1.整数类型byte b100;short s10000;int i1000000000;//注意长整型long要加L后缀才能最大化long l900000000000000000L;System.out.println(byte:b);System.out.println(short:s);System.out.println(int:i);System.out.println(long:l);//2.浮点型//注意小数默认是double如果要用float需要再数字后面加f或者Ffloat f34.67f;double d34.67;//char类型,char必须用单引号包围只能一个字符char c1A;char c22;//booleanboolean b1false;}注意事项 1.整数short int long 就是取值范围不一样对计算没有影响当然计算性能存储越低性能越高long后面需要增加L/l后缀 2.浮点型:小数默认为double类型float要加l/L后缀double计算精度高但性能差些但高精度计算用BigDecmal小数存在计算精度问题 3.基础类型不能赋null只有对应包装类才行 默认值和初始化 每一种类型都有一个默认值除基本类型外其他的类型的默认值都是 null因为它们都是引用类型。整数默认为 int 类型浮点数默认为 double 类型。 代码 public float f;public double d;public boolean b;private int i;private Boolean b3;Testpublic void t2(){//静态方法有默认值System.out.println(f); //0System.out.println(d); //0System.out.println(i); //0System.out.println(b); //falseSystem.out.println(b3); //nullboolean b1;System.out.println(b1); //编译不通过}注意事项 1.只有为class的字段属性声明才有默认值 2.在方法内声明的变量如果不赋初始值编译不通过 2.5.2 基础数据和包装类
Java 是面向对象的语言但是为了便于开发者的使用Java 中却沿用了 C 语言的基本数据类型在进行基本的数据计算时开发者可以直接使用基础类。但是基本数据类型是不具备对象的特征的不能调用方法而且基本数据类型不能存入集合中所以就需要将基础数据类型实例封装为 Java 对象使其具有了对象的属性和方法。
基础类型和包装类的区别 存储位置不同 基本数据类型直接将值放在栈中 包装类型是把对象放在堆中然后通过对象的引用来调用他们 初始值不同 int的初始值为 0 、 boolean的初始值为false 包装类型的初始值为null 使用方式不同 基本数据类型直接赋值使用就好 在集合如 coolectionMap 中只能使用包装类型 在应用场景中MVC模式的form-vo,Dto,PO对象的属性最好都用包装类因为基础类型都有默认值0或者false,在实际应用中null和0,false是有实际意义的 包装类是java对象封装有相关方法而基础类型没有 比如Integer.valueOf()等
为什么还要保留基础类型
在 Java 中使用 new 关键字创建的对象存储在堆中并且通过栈中的引用来使用这些对象所以对象本身来说是比较消耗资源的。基本类型存储在栈里因为栈的效率高所以保留了基本类型。变量的值存储在栈中方法执行时创建结束时销毁因此更加高效。使用基本数据类型参与计算时的性能要比使用包装类的高。
基础类型之间的转换 1基础类型自动转化 1.范围小的类型可以自动转换成范围大的类型。 2.整型可以自动转换成浮点型 3.反之范围大的转化为范围小的必须强制转换 4.范围:short-int-long-float-double 从小到大 示例代码 Testpublic void t3(){System.out.println(1.自动转换);byte i12;short i2i1;int i3i2;long i4i3;float f13.45f;double f2f1;float f3i3;double f4i4;}2强制执行 范围大的转化为范围小的必须用强制转换 范围大的类型需要强制转换成范围小的类型否则会精度丢失。 强制类型转换可能会导致数据溢出或者产生负数。 范围小到范围大的的转换也可以用强制转化和自动转换效果一样 Testpublic void t4(){System.out.println(2.强制转换);double f134.56565;float f2(float) f1;int i(int)f1;System.out.println(i);//范围小的转换也可以用强制转化和自动转换效果一样int i134;float f3(float)i1; }基本类型和包装类的转换 基本类型与包装类之间的转换需要使用到自动装箱和拆箱的操作。 Testpublic void t5(){System.out.println(3.基本类型和封装类转换);int i10;Integer i1i; //自动装箱Integer i230;int i3i2;//自动拆箱}包装类的常用方法 1.包装类对象包装类.valueOf(对应的基础类型) 2.基础数据类型/包装类对象包装类.parseXXX(字符串) 字符串转化成数据类型 Testpublic void t6() {System.out.println(4.包装类的常用方法);Integer i Integer.valueOf(2);int i1 Integer.parseInt(344); //字符串转成整数Integer i2 Integer.parseInt(34444); //实际是转化成int,int在装箱成IntegerSystem.out.println(i);System.out.println(i1);System.out.println(i2);}2.6 字符串
2.6.1 char/String区别
1.char和String的区别 char是字符类型是基础数据类型长度固定用单引号表示 如 c‘谢’ String是字符串类型不是基础数据类型长度无法确定用双引号表示 str“傻啊”。 关于String类。 (1)、String类时final类所以是不可继承的 ( 2)、String类是的本质是字符数组char[] ( 3)、Java运行时会维护一个String PoolString池JavaDoc翻译很模糊“字符串缓冲区”。String池用来存放运行时中产 生的各种字符串并且池中的字符串的内容不重复。而一般对象不存在这个缓冲池并且创建的对象仅仅存在于方法的堆 栈区。 4.String虽然是对象但传参也是值传递不是地址传递 Testpublic void t7() {String sabc;Character c中;char[] cs s.toCharArray();for (char c1 : cs) {System.out.println(c1);}char[] cs2{天,地,人};String s1new String(cs2);System.out.println(s1);}2.6.2 .关于String的创建方式
字符串有两种创建方式String s1“a”; String snew String(“a”)其逻辑是不一样的 1.直接创建 String str1 “123” 直接创建的 String 类的数据存储在公共的常量池中Java 的常量优化机制即直接创建的相同值的不同 String 类的引用相同。 2.new 创建 String str1 new String(“123”) 通过 new 关键字创建的 String 和其他一般的类的创建一样数据是存储在 String 类的对象的堆上即通过 new 关键字创建的相同值的不同 String 类的引用不同。 String str1 Java;
String str2 Java;
String str3 str2 ;
String str4new String(Java);
String str5new String(Java);
String str6str1;
String str7str4
System.out.println(str1 str2); // Output: true
System.out.println(str2 str3); // Output: false
System.out.println(str4 str5); // Output: false
System.out.println(str1 str5); // Output: false
System.out.println(str1 str6); // Output: true
System.out.println(str4 str7); // Output: true代码说明 (str1 str2) true 直接创建String,其实就是放到常量池里的对象直接创建时,先去常量池寻找如果有则引用所以这两个时一个东西 (str2 str3false str3 str2 “”;代码实际上是创建了一个StringBuild对象已经是两个对象了 (str4 str4false 两个字符串都是new String(“Java”),是两个对象所以为false
2.6.3 String StringBuffer StringBuild区别
1.字符串String 字符串类是final修饰不可继承和修改的
String sa;
ssb;其实是产生了两个字符串执行ss“b”;后sa就被丢弃在公共常量池里如果进行大量的修改 会导致性能很差。 2.字符串StringBuffer 在 Java1.0 的时候若要对字符串进行大量修改应当使用 StringBuffer它是可修改的同时当时的开发人员考虑到多个线程对一个字符串的修改可能出现线程不安全的问题于是让 StringBuffer 在拥有可修改字符串的功能的情况下又给它加上了线程安全的机制。看到这里是不是觉得还挺好挺正常的但是要知道一个前提那就是在 Java5 之前的 Java 在处理字符串的速度上一直被别人诟病原因出在哪里原因就在于这个 StringBuffer 上面。
StringBuffer 本来是为了实现大量修改字符串的功能而出现的但却因为 Java 的开发人员给它加了个线程安全的功能导致它执行效率极大地下降。这个线程安全的功能的实现并不是像我们现在用的方法当时只是保证没有异常抛出程序可以正常运行下去而已。在 Java 中要实现字符串的相加用加法运算符将两个字符串相加即可。但在这个过程中Java5 之前是有 String 自动隐含地转换成 StringBuffer再进行操作这一个步骤的毕竟 String 类不可直接修改。只要有这些步骤就可以实现字符串的修改但是呢StringBuffer 有个线程安全的功能它会在上面提到的步骤中还额外的执行一些功能以保证线程的安全而且这里实现线程安全的方式和我们现在用锁的方式是不一样的它这里的实现线程安全的方式极为繁琐且复杂这就大大降低了 StringBuffer 的执行效率以至于后来被广大程序员诟病。 3.字符串StringBuilder 我们仔细地想一下实际上也并没有多少地方需要在修改字符串的同时保证线程安全就算有我们给它加个锁就行。基于这种想法在 StringBuffer 出现 10 年之后Java 的开发人员回过头看这个问题才发现 StringBuffer 的实现是多么的愚蠢于是后来在 Java5 就有了 StringBuilder。StringBuilder 同样可以快速高效地修改字符串同时不是线程安全的。虽然它不是线程安全的但是它的执行效率却比 StringBuffer 要高上了不少。在 Java5 之后的版本中字符串相加隐含的转化过程中不再将 String 转化为 StringBuffer而是转化成 StringBuilder。
总结 在大量操作字符串时java已经优化了不推荐使用StringBuffer
2.7数组
2.7.1 数组定义
数组有多种定义方式 Testpublic void t1() {//第一种定义数组的方法int[] array1 {1, 2, 3};//直接赋值静态初始化//int[]是数组的类型array为数组名随意取名字//第二种定义数组的方法int[] array2 new int[]{1, 2, 3, 4};//数组的动态初始化//第三种定义数组的方法int[] array3 new int[10];//只是分配了内存但是没有进行赋值默认值都是0System.out.println(array3[2]); //0//第四种定义数组的方法int[] array4;array4 new int[]{1, 2, 3};//一定要为数组符初值不然编译器会报错int[] array5null;//等价int[] array4}4.注意事项
静态初始化虽然没有指定数组的长度编译器在编译时会根据{}中元素个数来确定数组的长度。静态初始化时, {}中数据类型必须与[]前数据类型一致。静态初始化可以简写省去后面的new T[]。T可以为任意数据类型。如果数组中存储元素类型为引用类型默认值为null。初始化后数组的长度是固定的不能动态扩容这个是和list最大的区别数组参数是地址引用不是值引用
地址引用
int[] array1 {1,2,3,4};
System.out.print(Arrays.toString(array1));//打印[1,2,3,4]int[] array2 array1;
array2[1] 99;
System.out.print(Arrays.toString(array1));//打印[1,99,3,4]不是[1,2,3,4]
System.out.print(Arrays.toString(array2));//打印[1,99,3,4]
首先创建一个数组array1并初始化赋值为1,2,3,4然后打印数组array1接着申请另一款空间用来创建array2且array2array1说明两个数组都指向同一块空间修改array2中的第二个元素也就相当于修改了array1中对应的元素。
2.7.2 数组帮助类Arrays
Arrays提供了几个很有用的数组帮助方法
方法说明toString把数组转化为字符串sort数组元素排序binarySearch查找元素在数组中的位置索引asList把数组转化成list
直接看代码一目了然 Testpublic void t3(){System.out.println(Arrays类的常见用法);int[] array{5,4,2,6,3};//1.打印String strArrays.toString(array);System.out.println(str);//[5, 4, 2, 6, 3]//2.数组大小排序Arrays.sort(array);System.out.println(Arrays.toString(array));//[2, 3, 4, 5, 6]//3.判断两个数组内容是否相等int[] array1{1,2,3};int[] array2{1,2,3};System.out.println(Arrays.equals(array1, array2)); //trueSystem.out.println(array1.equals(array2));//false不能采用这个方法判断数组内容//3.查找某个元素的索引int[] array3{1,2,3};int indexArrays.binarySearch(array3,2);System.out.println(index); //1//注意事项如果没有则返回小于0如果多个则返回第一个int[] array4{1,2,3,2};System.out.println(Arrays.binarySearch(array4, 2));//1System.out.println(ddd:Arrays.binarySearch(array4, 4));//小于零//4.转化成list数据类型Integer[] array5{1,2,3};//如果是对象则直接List对应的数组元素类型ListInteger listArrays.asList(array5);for (Integer i : list) {System.out.println(i);}// list.add(9); //运行报错不能新增和删除// list.remove(0);//运行报错不能新增和删除/***注意如果数组是基本数据类型用Array.asList是无法转化的。需要借助第三方先把基本类型数组转化成对应的包装类数组如Apache Commons Lang3*/int[] array6{1,2,3,5};Integer[] array7 ArrayUtils.toObject(array6);//4.copy值int[] arr1 {1, 2, 3};int[] arr2 Arrays.copyOf(arr1, 5);System.out.println(Arrays.toString(arr2)); //[1, 2, 3, 0, 0]//注意copyOf是值copy不是地址引用arr2[3]20;System.out.println(Arrays.toString(arr2));//[1, 2, 3, 20, 0]System.out.println(Arrays.toString(arr1));//[1, 2, 3]//copyOfRange方法提供了开始索引int[] arr3 new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};int[] arr4 new int[5];arr4 Arrays.copyOfRange(arr3,3,5);System.out.println(Arrays.toString(arr4));//[4, 5]}2.7.3 Apache Commons Lang3
org.apache.commons.lang3.ArrayUtils这个类也很大扩展了数组的操作具体查看apache文档
2.8 equals和、compareTo区别
2.8.1 和equals 是一个运算符用于比较两个对象的引用是否相同即它们是否指向内存中的相同位置。equals 是一个方法通常在Object类中定义它用于比较两个对象的内容是否相等。默认情况下equals方法执行与相同的引用比较但它可以被子类重写以提供自定义的相等性逻辑
“ ”在哪些情况下比较的是对象内容而不是引用
在Java中 运算符通常比较的是对象的引用。但在以下情况下 可以比较对象的内容而不是引用对于基本数据类型如int、char等 比较的是它们的值而不是引用。字符串常量池对于字符串字面值就是String s“123”不是String snew String(“123”);Java使用常量池来存储它们因此相同的字符串字面值使用比较通常会返回true。
代码1
Testpublic void t1(){//基本类型数据数值、字符、布尔的值一样则为truechar c1a;char c2a;float f13.5f;float f23.5f;double f33.5;int i11;int i21;long i31l;System.out.println(c1c2);//trueSystem.out.println(f1f2);//trueSystem.out.println(f1f3);//trueSystem.out.println(i1i2);//trueSystem.out.println(i1i3);//true}代码2 字符串是一个对象又有基础数据的特殊性可参考2.6.2
Testpublic void t2(){String s1123;String s2123;String s3s1;String s4s2;String s5new String(123);String s6new String(123);String s7s5;//sxx是直接声明,String是final常量性质和基础数据类型一样s1,s2都指向同一个内存地址System.out.println(s1s2); //true//所有变量赋值的语法指针都是一样System.out.println(s1s3); //true//因为String是final类型s2实际是创建一个对象System.out.println(s1s4); //false//两个不同对象内存地址不一样System.out.println(s5s6); //false//所有变量赋值的语法指针都是一样System.out.println(s5s7); //true//如果是euqal比较这几个都返回trueSystem.out.println( //trues1.equals(s2) s1.equals(s3) s1.equals(s4) s5.equals(s6));}
}代码3标准vo对象
Testpublic void t3(){TestVO vo1new TestVO(1,jzk);TestVO vo2vo1;TestVO vo3new TestVO(1,jzk);//内存指针一样System.out.println(vo1vo2);//true//两个不同对象System.out.println(vo1vo3);//false//三个对象值都是一样的System.out.println(vo1.equals(vo2) vo2.equals(vo3));//true//vo2修改了值因为vo1指针和他一致所以vo1也会改变最后他们都是一致的vo2.setName(奎哥);System.out.println(vo1vo2);//true//值已经改变了System.out.println(vo3.equals(vo1));//false}equals 和 hashCode 之间有什么关系
equals 和 hashCode 在Java中通常一起使用以维护对象在散列集合如HashMap和HashSet中的正确行为。 如果两个对象相等根据equals方法的定义那么它们的hashCode值应该相同。 也就是说如果重写了一个类的equals方法通常也需要重写hashCode方法以便它们保持一致。 这是因为散列集合使用对象的hashCode值来确定它们在内部存储结构中的位置。
2.8.2 compareTo obj.compareTo(object otherstr); 仅仅知道两个字符串是否相同是不够的。对于排序应用来说必须知道一个字符串是大于、等于还是小于另一个。一个字符串小于另一个指的是它在字典中先出现。而一个字符串大于另一个指的是它在字典中后出现。字符串String的 compareTo() 方法实现了这种功能。
compareTo() 方法用于按字典顺序比较两个字符串的大小该比较是基于字符串各个字符的 Unicode 值。如果两个字符串调用 equals() 方法返回 true那么调用 compareTo() 方法会返回 0,如果前者大则大于0否则小于0compareTo只能用于对象不能用于基础数据类型他实际上是Comparable接口类的方法实现这个接口的有:String、基础数据类型的包装类、Date、BigDecimal 等
代码 Testpublic void t4(){//字符串比较String s1a;String s2abc;System.out.println(s1.compareTo(s2));//基本类型的包装类比较Integer i13;Integer i25;System.out.println(i1.compareTo(i2));//0System.out.println(i1i2);//true//日期Date,BigDecimalDate d1 DateUtil.getDateByStr(2003-10-01, DateUtil.date_gs);Date d2 DateUtil.getDateByStr(2004-09-01, DateUtil.date_gs);System.out.println(d1.compareTo(d2));//0BigDecimal bg1new BigDecimal(1.0);BigDecimal bg2new BigDecimal(1.00);System.out.println(bg1.equals(bg2)); //返回的是false,所以比较BigDecimal不要用equalsSystem.out.println(bg1.compareTo(bg2));//0}
}2.9代码块、内部类和匿名类
2.9.1代码块 1.定义 类里用{}包裹起来的代码称为代码块代码块有三种类型 1.静态代码块 用static关键字修饰叫静态代码块 2.同步代码块 使用synchronize关键字修饰,并使用{}“括起来的代码片段.它表示在同一时间只能有一个线程进入到该方法块中,是一种多线程保护机制. 3.非静态代码块 在类中没与任何的前缀或后缀,并使用”{}括起来的代码片段叫非静态代码块也叫构造代码块 //非静态代码块{int i0;System.out.println(非静态代码块........);}//静态代码块static {int i10;System.out.println(静态代码块........);}静态代码块特点 静态代码块使用static关键字进行修饰静态代码块的内部可以有输出语句静态代码块在类加载时执行并且只会执行一次因为一个类只会加载一次静态代码块用于初始化类但是初始化的是类的静态属性类的非静态属性是无法在静态代码块中被初始化的若是在一个类中存在多个静态代码块那么执行时会按照这些静态代码块的定义顺序来执行若是在静态代码块中存在调用那么只能调用静态的属性和方法不能调用非静态的属性和方法 非静态代码块特点又叫构造代码块有点类似构造函数 非静态代码块不使用static关键字进行修饰非静态代码块的内部可以有输出语句非静态代码块随着对象的创建而执行每创建一个对象便会调用一次非静态代码块因为非静态代码块是用于初始化对象的因此每次使用new关键字创建一个对象都会新增一个对象并使用非静态代码块对其初始化非静态代码块可以在创建对象时对对象的属性进行初始化若是在一个类中定义了多个非静态代码块则这些非静态代码块会按照定义的先后顺序来执行非静态代码块中可以调用该类的静态属性、静态方法、非静态属性、非静态方法因为静态的内容是随着类的加载而加载的而非静态内容是在静态内容之后被加载的因此非静态代码块调用已经存在的静态内容是完全没有问题的 在一个对象实例化时的执行顺序 1.首先执行静态代码块在类初始化执行。静态代码块只执行一次 2.其实执行非静态代码块在对象实例化new时执行每次实例化都会执行一次 3.最后执行构造函数
代码 对象类
public class CodePiece {public static final String sdd;//分静态代码块{int i0;System.out.println(非静态代码块.......2);}//静态代码块static {int i10;System.out.println(静态代码块........1);}private int i2;public CodePiece(){System.out.println(构造函数.............3);// System.out.println(ii);}}
测试
Testpublic void t1() throws ClassNotFoundException {// System.out.println( CodePiece.s);//第一次要执行静态代码块Class clsClass.forName(com.jsoft.ref.CodePiece);//第二次将不会执行静态代码块Class cls2Class.forName(com.jsoft.ref.CodePiece);CodePiece v1new CodePiece(); //执行非静态代码代码和构造函数CodePiece v2new CodePiece();//执行非静态代码代码和构造函数}效果
静态代码块........1
非静态代码块.......2
构造函数.............3
非静态代码块.......2
构造函数.............3 应用场景 1.我们只需要类加载一次执行的时候我们使用静态代码块应用场景多 2.如果有多个构造函数都要执行共有的代码我们把这个部分代码放置到非静态代码块里 2.9.2内部类 定义 把一个类定义在令一个类里叫内部类内部类分为静态内部类和非静态内部类两种静态内部类用 static关键字修饰内部类也可以定义成只有外部类能访问的私有类
public class MuCls {private Integer id;//非静态内部内类public class InnerClass1{}//静态内部类public static class InnerClass2{}//如果一个内部类不想让外部访问可以声明一个私有的内部类privae class InnerClass3{}
}内部类语法:内部类和外部类可以非常方便的通信 A{ class B{} }
类型外部访问内部内部访问外部非静态内部类B bnew B();b.字段b.方法()1.外部类非静态字段或者方法:A.this.字段A.this.方法()2.外部类静态字段或方法 :A.字段A.方法()静态内部类1.静态字段和方法:B.字段B.方法() 2.非静态字段和方法:B bnew B();b.字段b.方法()1.外部类非静态字段或者方法:A anew A();a.字段;a.方法() 2.外部类静态字段或方法 :A.字段A.方法()
注意事项 1.非静态内部类里不能有静态的字段和方法 2.内外部类通信和 private public无关因为都在同一个类里 3.一般情况下代码外部类为主所以非静态内部类使用多一些
public class MuCls {private Integer id;public static String type;public void outM1(){System.out.println(外部类方法);}//操作非静态内部类public void outM2(){//访问非静态内部类必须用new实例化InnerClass1 innerClass1new InnerClass1();//访问内部类字段Integer iinnerClass1.id; //不管内部类字段是private还是public都可以访问//调用内部类方法innerClass1.innerM1();}//访问静态内部类public void outM3(){//访问静态内部类的静态字段和属性可以直接访问Integer sexInnerClass2.sex;InnerClass2.help();//访问非静态字段和属性还是要new 内部类InnerClass2 innerClass2new InnerClass2();//访问内部类字段String nameinnerClass2.name; //不管内部类字段是private还是public都可以访问//调用内部类方法innerClass2.innerM2();}//外部静态方法public static void outM4(){System.out.println(外部类静态方法);}//非静态内部内类//注意非静态类里不能用static修饰字段和方法public class InnerClass1{private Integer id;public void innerM1(){System.out.println(非静态类方法innerM1());}//访问外部类public void innerM2(){// 外部类非静态字段或者方法外部类名.this.字段或者方法Integer outIdMuCls.this.id; //非静态字段MuCls.this.outM1();//非静态方法//外部类静态字段或方法外部名类.字段或者方法String outTypeMuCls.type;//静态字段MuCls.outM4();//静态方法}}//静态内部类//静态类里可以用static修饰字段和方法public static class InnerClass2{//内部类静态字段private static Integer sex;private String name;//内部类静态方法public static void help(){}public void innerM2(){System.out.println(非静态类方法innerM2());}//访问外部类public void innerM3(){// 静态类不能直接访问外部类的非静态字段和方法需要new 外部类MuCls muClsnew MuCls();Integer outIdmuCls.id;muCls.outM1();//外部类静态字段或方法外部名类.字段或者方法String outTypeMuCls.type;//静态字段MuCls.outM4();//静态方法}}
} 第三方类调用含有内部类的类 A{ B{} }
非静态内部内静态内部类1.得到内部对象:A.B bnew A().new B();2.调用内部类方法:b.方法()1.访问静态类里静态方法和字段: A.B.字段A.B.方法()2.访问内部类非静态字段和方法:A.B bnew A.B();b.字段;b.方法();
public class InnerTest {/***非静态内部类测试1.外部调用必须先实例化外部类获得外部类的对象2.获得内部类对象外部类的对象.new 内部类名*/Testpublic void t3(){MuCls muClsnew MuCls();//得到内部类对象MuCls.InnerClass1 innerClass1muCls.new InnerClass1();//调用内部类方法innerClass1.innerM1();}/***静态内部类调用测试1.内部静态类里面的静态属性和方法可以直接访问2.内部静态类的实例化和非静态类不一样可以直接new*/Testpublic void t4() {//1.访问静态内部类的静态字段和方法MuCls.InnerClass2.help();//2.访问静态内部类的非静态字段和方法//静态内部类实际上是独立的一个类可直接new生成对象和非静态内部内不一样MuCls.InnerClass2 innerClass2new MuCls.InnerClass2();innerClass2.innerM2();}
}什么场景下使用内部类 有时候一个类太复杂我们把一个类里面的一些属性和方法抽取成一个内部类隐藏复杂逻辑 而且内部方法需要互相方便的访问比抽取成一个外部类更方便。
2.9.3匿名类 什么是匿名类 使用 Java 编程时常常需要创建不会被再次使用的对象。 在这种情况下非常适合使用一种特殊的内部类匿名内部类。 这种类没有名称是在同一条语句中声明和创建的。 要使用匿名内部类可将引用对象的代码替换为关键字 new、对构造函数的调用以及用大括号{和}括起的类定义。 既然是匿名类所以你无法在别的地方实例化和使用这个类。匿名内部类也可用于接口interface的实现 语法: new 类名().方法() 准备类
public class NoName {public void play(){System.out.println(执行NoName.play());}public void eat(){System.out.println(执行NoName.eat());}}public interface NoNameInterface {public void play();public void eat();
} 声明一个NoName的匿名对象 Testpublic void t1(){//正常声明对象NoName noNamenew NoName();noName.play();//如果我们这个noName不在其他地方使用而且只调用一个方法就可以简写如下new NoName().play();}更常见的一种写法 new 类名或者接口名() {重写方法;
} 重写匿名类的方法 //在方法体里重写匿名类的方法Testpublic void t2() {new NoName() { //重写NoName类的play()方法Overridepublic void play() {System.out.println(重写方法play());}}.play();}//重写参数类里的方法Testpublic void t3() {param(new NoName() {Overridepublic void play() {System.out.println(重写参数类的play());}});/*** 等价于public class A extends NoName{public void play() {System.out.println(重写参数类的play());}}NoName anew A();param(a);*/}private void param(NoName noName) {noName.play();}接口的匿名实现类这种写法场景更多 代码 //接口实现匿名类的写法Testpublic void t4(){new NoNameInterface(){Overridepublic void play(){System.out.println(接口实现匿名类.play());}Overridepublic void eat(){System.out.println(接口实现匿名类.eat());}}.play();}//如果接口里有多个方法被调用则可以用下面这种方式Testpublic void t5(){NoNameInterface service new NoNameInterface(){Overridepublic void play(){System.out.println(接口实现匿名类.play());}Overridepublic void eat(){System.out.println(接口实现匿名类.eat());}};service.play();service.eat();}//方法参数是接口的匿名实现类写法Testpublic void t6(){param2(new NoNameInterface(){Overridepublic void play() {System.out.println(参数接口实现匿名类.play());}Overridepublic void eat() {System.out.println(参数接口实现匿名类.eat());}});}private void param2(NoNameInterface service) {service.play();}在使用匿名内部类的过程中我们需要注意如下几点 1、使用匿名内部类时我们必须是继承一个类或者实现一个接口但是两者不可兼得同时也只能继承一个类或者实现一个接口。
2、匿名内部类中是不能定义构造函数的。
3、匿名内部类中不能存在任何的静态成员变量和静态方法。
4、匿名内部类为局部内部类所以局部内部类的所有限制同样对匿名内部类生效。
5、匿名内部类不能是抽象的它必须要实现继承的类或者实现的接口的所有抽象方法。
2.10枚举
2.11 集合
2.12 日期类LocalDate
2.13 java泛型及通配符
2.14文件流IO
