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 i=0;i<list.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 listList<Integer> list= Arrays.asList(1,2,3,4);System.out.println("for-each遍历list-----------");for (Integer i : list) {System.out.println("list:"+i);}//1-3 遍历mapMap<String,String> map=new HashMap<>();System.out.println("for-each遍历Map-----------");map.put("1", "111");map.put("2", "222");map.put("3", "222");//得到key的collectonSet<String> keySet=map.keySet();for(String key:keySet){System.out.println("map["+key+"]="+map.get(key));}}@Testpublic void t2(){System.out.println("=======Iterator循环================");//1-2 listList<Integer> list= Arrays.asList(1,2,3,4);System.out.println("Iterator 遍历list-----------");Iterator iter=list.iterator();while (iter.hasNext()) {System.out.println("list:"+iter.next());}//1-3 遍历mapMap<String,String> map=new HashMap<>();System.out.println("Iterator 遍历Map-----------");map.put("1", "111");map.put("2", "222");map.put("3", "222");//得到key的collectonSet<String> keySet=map.keySet();iter=keySet.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 listList<Integer> 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表达式List<Integer> list= Arrays.asList(1,2,3,4);System.out.println("lambda表达式 遍历list-----------");list.forEach((value)->{System.out.println(value);});//Map的lambda表达式Map<String,String> map=new 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) {temp+=like+",";}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.使用List=Arrays.asList(数组对象)，最简单，但不能新增删除
2.List=new 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};List<Object> list1= Arrays.asList(intArray);// list1.add(4);   //不能再新增，否则要报异常printList(list1);//自定义数组TestVO[] objArray={new TestVO(1,"jzk"),new TestVO(2,"张三")};list1=Arrays.asList(objArray);printList(list1);//2--Arrays.asList作为构造参数传入，可新增，但性能差System.out.println("2--Arrays.asList作为构造参数传入，可新增，但性能差");list1=new ArrayList<>(Arrays.asList(intArray));list1.add(4);printList(list1);//3--Collections.addAll(list,数组);能新增删除，性能好System.out.println("3--Collections.addAll(list,数组);能新增删除，性能好");list1=new 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(List<Object> list){for (Object o : list) {System.out.println(o);}}

2.3.2 list转数组

核心用到list.toArray()方法
1.Object[] arrays=list.toArray(); 只能获得Object数组
2.对象数组=list.toArray(new 对象[list.size] ) ;//可以获得对应的对象数组

测试代码

@Testpublic void list2array(){List<TestVO> list=getTestVO();System.out.println("方法1：list.toArray()===========");//注意：只能用转换成Object[]数组，不能强制转化Object[] arrays=list.toArray();for (Object array : arrays) {System.out.println((TestVO)array);}System.out.println("方法2：list.toArray(数组对象)===========");//这样可获得实际的类TestVO[] vos=new TestVO[list.size()];list.toArray(vos );for (TestVO vo : vos) {System.out.println(vo);}//或者这样写System.out.println("方法3：list.toArray(数组对象)简写===========");vos=list.toArray(new TestVO[list.size()]);for (TestVO vo : vos) {System.out.println(vo);}System.out.println("方法4：String[] strings = list.stream().toArray(String[]::new);===");TestVO[] vos2=list.stream().toArray( TestVO[]::new);for (TestVO vo : vos2) {System.out.println(vo);}}private void printList(List<Object> list){for (Object o : list) {System.out.println(o);}}private List<TestVO> getTestVO(){List<TestVO> list=new 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 str="a";double db= Double.parseDouble("34.5");Double db1=45.2;Integer zs=Integer.valueOf(100);int zs1=200;boolean b=false;Boolean b1= true;System.out.println("str="+str);System.out.println("db="+db);System.out.println("db1="+db1);System.out.println("zs="+zs);System.out.println("zs1="+zs1);System.out.println("b="+b);System.out.println("b1="+b1);change1(str,db,db1,zs,zs1);System.out.println("str="+str);System.out.println("db="+db);System.out.println("db1="+db1);System.out.println("zs="+zs);System.out.println("zs1="+zs1);}private void change1(String str,double db,Double db1,int zs,Integer zs1){System.out.println("============change==========");str="b";db=-45.2;db1=-22.4;zs=-1;zs1=-2;}

执行效果，可以看出这些都是值传递，被引用后并没有改变以前值：

str=a
db=34.5
db1=45.2
zs=100
zs1=200
b=false
b1=true
============change==========
str=a
db=34.5
db1=45.2
zs=100
zs1=200

2.4.2 地址传递

与基本数据类型不同，Java 中的对象类型（如数组、集合、自定义类等）则是以地址传递的方式进行参数传递。这意味着当我们将一个对象作为参数传递给一个方法时，方法内部使用的是这个对象的引用，而不是对象本身。

执行过程

• 创建一个对象并将其引用赋值给一个变量。

• 将这个变量作为参数传递给一个方法。

• 在方法内部，参数变量接收到了对原始对象的引用。

• 在方法内部修改参数变量所指向的对象时，原始对象也会受到影响。

• 方法执行完毕后，返回到原始调用处，可以通过原始变量访问到被修改后的对象。

对象的引用传递意味着传递的是对象的引用，通过引用可以访问和修改原始对象的属性。

测试代码：

 @Testpublic void addressPass(){StringBuffer sb=new StringBuffer("aa");TestVO vo=new TestVO(1,"蒋增奎");String[] array={"1","2","3"};List<Integer> list=new ArrayList<>();list.add(1);list.add(2);Map<String,Integer> map=new 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,List<Integer> list,Map<String,Integer> map){sb.append("dd");vo.setName("蒋大爷");array[0]="改值11";list.add(3);map.put("3",333);}

效果，地址引用值都会被改变

sb:aa
vo:TestVO(id=1, name=蒋增奎)
array:[1, 2, 3]
list:[1, 2]
map:{1=11, 2=22}
================
sb:aadd
vo:TestVO(id=1, name=蒋大爷)
array:[改值11, 2, 3]
list:[1, 2, 3]
map:{1=11, 2=22, 3=333}

2.4.3易错点总结

易错点
java对象：String ,int等对应的封装类Integer，java.util.Date,BigDecimal是值传递，不是地址传递，虽然他们是对象

值传递VS地址传递

2.5 数组

数组帮助类Arrays

2.5 基本数据类型和包装类

2.5集合

2.6文件流

2.7java代码块、内部类和匿名类

2.8 java泛型及通配符

2.9 日期类LocalDate

2.10枚举

2.11 java常见数据结构