java进阶(二)-java小干货

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 {
    @Test
    public 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 list
        List<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 遍历map
        Map<String,String> map=new HashMap<>();
        System.out.println("for-each遍历Map-----------");
        map.put("1", "111");
        map.put("2", "222");
        map.put("3", "222");
        //得到key的collecton
        Set<String> keySet=map.keySet();
        for(String key:keySet){
            System.out.println("map["+key+"]="+map.get(key));
        }

    }

    @Test
    public void t2(){
        System.out.println("=======Iterator循环================");
        //1-2 list
        List<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 遍历map
        Map<String,String> map=new HashMap<>();
        System.out.println("Iterator 遍历Map-----------");
        map.put("1", "111");
        map.put("2", "222");
        map.put("3", "222");
        //得到key的collecton
        Set<String> keySet=map.keySet();
        iter=keySet.iterator();
        while (iter.hasNext()) {
            String key= (String) iter.next();
            System.out.println("map["+key+"]="+map.get(key));
        }
    }

    @Test
    public 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 list
        List<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));
        }


    }

    @Test
    public 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);
    }



    @Test
    public 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());

@Test
    public 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] ) ;//可以获得对应的对象数组

测试代码

    @Test
    public 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 中，基本数据类型（如整数、布尔值等）都是以值传递的方式进行参数传递。这意味着当我们将一个基本数据类型作为参数传递给一个方法时，方法内部会创建一个新的变量来存储这个参数的值，而不会影响原始的变量。

执行过程

• 首先，在调用方法时，将实际参数的值复制一份，并将这份副本传递给方法进行操作。
• 在方法内部，这个副本的值被赋给一个新的局部变量。
• 在方法执行过程中，对该局部变量的任何改动都不会影响原始的变量，因为它们指向的是不同的内存空间。
• 当方法执行完毕后，这个局部变量和方法的栈帧都会被销毁，而原始的变量的值保持不变。

基本数据类型的传递过程中，传入的值被复制到方法内部，并在方法内部进行操作，但不会影响原始变量的值。

@Test
    public 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 中的对象类型（如数组、集合、自定义类等）则是以地址传递的方式进行参数传递。这意味着当我们将一个对象作为参数传递给一个方法时，方法内部使用的是这个对象的引用，而不是对象本身。

执行过程

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

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

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

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

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

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

测试代码：

 @Test
    public 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常见数据结构