java学习笔记——匿名对象，ArrayList集合，遍历

5月19第一节
匿名对象

创建对象的标准格式：

• 类名称 对象名 = new 类名称（）；

匿名对象就是只有右边的对象，没有左边的名字和赋值运算
new 类名称（）；

注意：

• 1.匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。
• 2.没有引用的对象就是内存中的垃圾，会被JVM中垃圾回收机制回收，匿名对象一创建就是垃圾。

引用：储存了某一个地址的变量

建议：

• 1、确定有一个对象只需使用唯一的一次
• 2、一般用于方法调用

定义一个类Student，给它一个属性name

匿名对象只能使用唯一的一次

引用类型数组
5月18第一节、第二节

想一想：这是把原本长度为10的数组扩容成了长度为11的数组吗
int[] arr = new int[10];
new代表创建的意思，在堆里面创建了一个数组，把数组的地址存入arr
arr = new int[11];
创建了一个新的数组，把新的数组的地址赋给了arr
所以原来的数组并没有变大，只是生成了一个新的数组，原来的数组就变为了垃圾

题目：
定义一个数组，用来存储3个Student对象。

在你的Student类里修改toString()方法


代码：Student类

public class Student {
     
    String name;


    //构造函数，无参数
    public Student() {
     
    }

    //构造函数，有参数
    public Student(String name) {
     

        this.name = name;
    }

    public void study() {
     
        System.out.println("学习");
    }

    //自己重写一个toString方法
    //toString方法来自祖宗类Object
    public String toString() {
     

        return this.name;
    }
}

代码：

public class Demo01 {
     
    public static void main(String[] args) {
     
        Student[] arr1 = new Student[3];//创建数组对象，长度为3

        Student s1 = new Student("王二小");
        Student s2 = new Student("王三小");
        Student s3 = new Student("王四小");

        arr1[0]=s1;//把s1,s2,s3赋值给数组元素
        arr1[1]=s2;
        arr1[2]=s3;

        System.out.println(Arrays.toString(arr1));//输出的是地址
        System.out.println(s1);
        System.out.println(s1.toString());
        System.out.println(s2);
        System.out.println(s3);
        //System.out.println(s1)=em.out.println(s1.toString())

    }
}

5月19第二节，接上面，集合ArryList

要添加一个新学生，创建一个新的数组

像上面那样创建数组是很麻烦的，所以可以选择引用集合ArrayLIst

数组的长度不可以发生改变。
但是ArrayList集合的长度是可以随意变化的。

对于ArrayList来说，有一个尖括号代表泛型。
jdk1.7开始，后面的泛型就可以省略了
泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。
注意：泛型只能是引用类型，不能是基本类型。

注意事项：
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
如果内容是空，得到的是空的中括号：[]

public class Demo02ArrayList {
     
    public static void main(String[] args) {
     
        //new ArrayList<>();创建对象,<>里代表泛型

        //创建一个空的集合
        ArrayList<Object> list1 = new ArrayList<>();

        Student s1=new Student("唐僧");
        Student s2=new Student("沙和尚");
        Student s3=new Student("猪八戒");
        Student s4=new Student("孙悟空");
        list1.add(s1);//添加学生到集合
        list1.add(s2);
        list1.add(s3);
        list1.add(s4);
        System.out.println(list1);

        //添加一名新的同学
        Student s5=new Student("妖怪");
        list1.add(s5);
        System.out.println(list1);

        //获取调用
        list1.get(0);
        System.out.println(list1.get(0));

        System.out.println(list1.size());//集合长度

        //删除元素
        //list1.remove(3);//删除集合第四个元素
        Student stu = (Student) list1.remove(3);
        System.out.println(stu);//输出删除的元素
        System.out.println(list1);
        System.out.println(list1.size());
    }
}

集合的遍历

public class Demo03ArrayListeach {
     
    public static void main(String[] args) {
     

        ArrayList<Object> list1 = new ArrayList<>();

        Student s1=new Student("唐僧");
        Student s2=new Student("沙和尚");
        Student s3=new Student("猪八戒");
        Student s4=new Student("孙悟空");
        list1.add(s1);//添加学生到集合
        list1.add(s2);
        list1.add(s3);
        list1.add(s4);

        //fori
        for (int i = 0; i < list1.size(); i++) {
     
            System.out.println(list1.get(i));
        }
        System.out.println("=======================");
        //foreach,iter+回车
        for (Object s : list1) {
     //??
            System.out.println(s);
        }
        
    }
}

如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”。

基本类型 包装类（引用类型，包装类都位于java.lang包下）
byte Byte
short Short
int Integer 【特殊】
long Long
float Float
double Double
char Character 【特殊】
boolean Boolean

从JDK 1.5+开始，支持自动装箱、自动拆箱。

自动装箱：基本类型 --> 包装类型
自动拆箱：包装类型 --> 基本类型

public class Demo05ArrayListBasic {
     
    public static void main(String[] args) {
     
        //int=>Integer,自动装箱
        Integer i=12;

        //Integer=>int,自动拆箱
        int num=i;

        //可以接受double类型的list
        ArrayList<Double> list = new ArrayList<Double>();
        list.add(23.8);
        list.add(78.99);
        list.add(12.43);
        list.add(34.3);
        System.out.println(list);
        System.out.println("====================");

        System.out.println(list.get(2));
        System.out.println("====================");
        double d = list.get(2);
        System.out.println(d);
    }
}

练习1：
生成6个1~33之间的随机整数，添加到集合，并遍历集合。

思路：
1.for循环
2.Random nextInt(33)+1
3.ArrayList
4.foreach

public class Demo05ArrayListPractice1 {
     
    public static void main(String[] args) {
     
        ArrayList<Integer> list = new ArrayList<Integer>();
        Random r= new Random();
        for (int i = 0; i < 6; i++) {
     

            int num = r.nextInt(33)+1;
            list.add(num);
        }
        //遍历
        for (Integer i : list) {
     
            System.out.print(i+" ");

        }
    }
}

练习2
用一个大集合存入20个随机数字(1-100)，定义一个方法，实现筛选其中的偶数元素，放到小集合当中，并返回小集合。
要求使用自定义的方法来实现筛选。

分析：
1.for Random
2.ArrayList listBig
3.调用方法,传参listBig
4.创建一个ArrayList listSmall
5.遍历listBig，判断偶数
6.如果是偶数，就存入listSmall

public class Demo05ArrayListPractice2 {
     
    public static void main(String[] args) {
     
        ArrayList<Integer> listBig = new ArrayList<Integer>();//创建ArrayList对象
        Random r = new Random();//创建Random对象

        //添加随机数到集合
        for (int i = 0; i < 20; i++) {
     
            int num = r.nextInt(100) + 1;
            listBig.add(num);
        }
        System.out.println(listBig);//输出一下，方便查看原来的大集合

        ArrayList<Integer> s=listS(listBig);//调用方法listS，传参listBig
        System.out.println(s);
    }

    public static ArrayList<Integer> listS(ArrayList<Integer> listBig) {
     

        ArrayList<Integer> listSmall = new ArrayList<>();//创建小集合listSmall

        //遍历listBig
        for (int i = 0; i < listBig.size(); i++) {
     

            Integer n = listBig.get(i);//获取元素

            //判断为偶数，添加到小集合当中
            if (n % 2 == 0) {
     
                listSmall.add(n);
            }

        }
        return listSmall;//返回小集合

    }
}