重踏学习Java路上_Day15(对象数组,集合类,列表)

1:对象数组(掌握)
    (1)数组既可以存储基本数据类型,也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。
    (2)案例:
        用数组存储5个学生对象,并遍历数组。

public class Student {
    // 成员变量
    private String name;
    private int age;

// 构造方法
    public Student() {
        super();
    }

public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

// 成员方法
    // getXxx()/setXxx()
    public String getName() {
        return name;
    }

public void setName(String name) {
        this.name = name;
    }

public int getAge() {
        return age;
    }

public void setAge(int age) {
        this.age = age;
    }

@Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
}

/*
 * 我有5个学生,请把这个5个学生的信息存储到数组中,并遍历数组,获取得到每一个学生信息。
 *         学生:Student
 *         成员变量:name,age
 *         构造方法:无参,带参
 *         成员方法:getXxx()/setXxx()
 *         存储学生的数组?自己想想应该是什么样子的?
 * 分析:
 *         A:创建学生类。
 *         B:创建学生数组(对象数组)。
 *         C:创建5个学生对象,并赋值。
 *         D:把C步骤的元素,放到数组中。
 *         E:遍历学生数组。
 */
public class ObjectArrayDemo {
    public static void main(String[] args) {
        // 创建学生数组(对象数组)。
        Student[] students = new Student[5];
        // for (int x = 0; x < students.length; x++) {
        // System.out.println(students[x]);
        // }
        // System.out.println("---------------------");

// 创建5个学生对象,并赋值。
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("风清扬", 30);
        Student s3 = new Student("刘意", 30);
        Student s4 = new Student("赵雅芝", 60);
        Student s5 = new Student("王力宏", 35);

// 把C步骤的元素,放到数组中。
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;
        students[3] = s4;
        students[4] = s5;

// 看到很相似,就想循环改
        // for (int x = 0; x < students.length; x++) {
        // students[x] = s + "" + (x + 1);
        // }
        // 这个是有问题的

// 遍历
        for (int x = 0; x < students.length; x++) {
            //System.out.println(students[x]);
            
            Student s = students[x];
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

2:集合(Collection)(掌握)
    (1)集合的由来?
        我们学习的是Java -- 面向对象 -- 操作很多对象 -- 存储 -- 容器(数组和StringBuffer) -- 数组
        而数组的长度固定,所以不适合做变化的需求,Java就提供了集合供我们使用。
    (2)集合和数组的区别?
        A:长度区别
            数组固定
            集合可变
        B:内容区别
            数组可以是基本类型,也可以是引用类型
            集合只能是引用类型
        C:元素内容
            数组只能存储同一种类型
            集合可以存储不同类型(其实集合一般存储的也是同一种类型)
    (3)集合的继承体系结构?
        由于需求不同,Java就提供了不同的集合类。这多个集合类的数据结构不同,但是它们都是要提供存储和遍历功能的,
        我们把它们的共性不断的向上提取,最终就形成了集合的继承体系结构图。
        
        Collection
            |--List
                |--ArrayList
                |--Vector
                |--LinkedList
            |--Set
                |--HashSet
                |--TreeSet
    (4)Collection的功能概述(自己补齐)
        A:添加功能
        B:删除功能
        C:判断功能
        D:获取功能
        E:长度功能
        F:交集(了解)
        G:把集合转数组(了解)
    (5)Collection集合的遍历
        A:把集合转数组(了解)
        B:迭代器(集合专用方式)
    (6)迭代器
        A:是集合的获取元素的方式。
        B:是依赖于集合而存在的。
        C:迭代器的原理和源码。
            a:为什么定义为了一个接口而不是实现类?
            b:看了看迭代器的内部类实现。
    (7)Collection集合的案例(遍历方式 迭代器)
        集合的操作步骤:
            A:创建集合对象
            B:创建元素对象
            C:把元素添加到集合
            D:遍历集合
    
        A:存储字符串并遍历
            import java.util.Collection;
            import java.util.ArrayList;
            import java.util.Iterator;
            
            public class CollectionDemo {
                public static void main(String[] args) {
                    //创建集合对象
                    Collection c = new ArrayList();
                    
                    //创建并添加元素
                    c.add("hello");
                    c.add("world");
                    c.add("java");
                    
                    //遍历集合
                    Iterator it = c.iterator();
                    while(it.hasNext()) {
                        String s =(String) it.next();
                        System.out.println(s);
                    }
                }
            }
        
        B:存储自定义对象并遍历
            public class Student {
                private String name;
                private int age;
                
                public Student(){}
                
                public Student(String name,int age) {
                    this.name = name;
                    this.age = age;
                }
                
                //getXxx()/setXxx()
            }
            
            import java.util.Collection;
            import java.util.ArrayList;
            import java.util.Iterator;
            
            public class StudentDemo {
                public static void main(String[] args) {
                    //创建集合对象
                    Collection c = new ArrayList();
                    
                    //创建学生对象
                    Student s1 = new Student("林青霞",27);
                    Student s2 = new Student("风清扬",30);
                    Student s3 = new Student("刘意",30);
                    Student s4 = new Student("武鑫",25);
                    Student s5 = new Student("刘晓曲",16);
                    
                    //添加元素
                    c.add(s1);
                    c.add(s2);
                    c.add(s3);
                    c.add(s4);
                    c.add(s5);
                    
                    //遍历集合
                    Iterator it = c.iterator();
                    while(it.hasNext()) {
                        Student s = (Student)it.next();
                        System.out.println(s.getName()+"---"+s.getAge());
                    }
                }
            }

3:集合(List)(掌握)
    (1)List是Collection的子接口
        特点:有序(存储顺序和取出顺序一致),可重复。
    (2)List的特有功能:(自己补齐)
        A:添加功能
        B:删除功能
        C:获取功能
        D:迭代器功能
        E:修改功能
    (3)List集合的特有遍历功能
        A:由size()和get()结合。
        B:代码演示
                    //创建集合对象
                    List list = new ArrayList();
                    
                    //创建并添加元素
                    list.add("hello");
                    list.add("world");
                    list.add("java");
                    
                    //遍历集合
                    Iterator it = list.iterator();
                    while(it.hasNext()) {
                        String s =(String) it.next();
                        System.out.println(s);
                    }
                    System.out.println("----------");
                    
                    for(int x=0; x<list.size(); x++) {
                        String s =(String) list.get(x);
                        System.out.println(s);
                    }
    (4)列表迭代器的特有功能;(了解)
        可以逆向遍历,但是要先正向遍历,所以无意义,基本不使用。
    (5)并发修改异常
        A:出现的现象
            迭代器遍历集合,集合修改集合元素
        B:原因
            迭代器是依赖于集合的,而集合的改变迭代器并不知道。
        C:解决方案
            a:迭代器遍历,迭代器修改(ListIterator)
                元素添加在刚才迭代的位置
            b:集合遍历,集合修改(size()和get())
                元素添加在集合的末尾
    (6)常见数据结构
        A:栈 先进后出
        B:队列 先进先出
        C:数组 查询快,增删慢
        D:链表 查询慢,增删快
    (7)List的子类特点(面试题)
        ArrayList
            底层数据结构是数组,查询快,增删慢。
            线程不安全,效率高。
        Vector
            底层数据结构是数组,查询快,增删慢。
            线程安全,效率低。
        LinkedList
            底层数据结构是链表,查询慢,增删快。
            线程不安全,效率高。
            
        到底使用谁呢?看需求?
        分析:
            要安全吗?
                要:Vector(即使要,也不使用这个,后面再说)
                不要:ArrayList或者LinkedList
                    查询多;ArrayList
                    增删多:LinkedList
                    
        什么都不知道,就用ArrayList。
    (8)List集合的案例(遍历方式 迭代器和普通for)
        A:存储字符串并遍历
        B:存储自定义对象并遍历

时间: 2024-10-05 21:18:59

重踏学习Java路上_Day15(对象数组,集合类,列表)的相关文章

重踏学习Java路上_Day27(反射,模式设计,jdk新特性)

1:反射(理解) (1)类的加载及类加载器 (2)反射: 通过字节码文件对象,去使用成员变量,构造方法,成员方法 (3)反射的使用 A:通过反射获取构造方法并使用 B:通过反射获取成员变量并使用 C:通过反射获取成员方法并使用 (4)反射案例 A:通过反射运行配置文件的内容 B:通过反射越过泛型检查 C:通过反射给任意的一个对象的任意的属性赋值为指定的值 (5)动态代理 2:设计模式 (1)装饰设计模式 BufferedReader br = new BufferedReader(new Inp

重踏学习Java路上_Day13(StringBuffer,Array与数组,Integer,Character)

1:StringBuffer(掌握)    (1)用字符串做拼接,比较耗时并且也耗内存,而这种拼接操作又是比较常见的,为了解决这个问题,Java就提供了       一个字符串缓冲区类.StringBuffer供我们使用.    (2)StringBuffer的构造方法        A:StringBuffer()        B:StringBuffer(int size)        C:StringBuffer(String str)    (3)StringBuffer的常见功能(

重踏学习Java路上_Day19(异常,File)

1:异常(理解) 异常的图解:     (1)异常就是Java程序在运行过程中出现的错误.    (2)异常的体系        Throwable            |--Error    严重问题,我们不处理.这种问题一般都是很严重的,比如说内存溢出.            |--Exception                |--RuntimeException  运行期发生问题:    这种问题我们也不处理,因为是你的问题,而且这个问题出现肯定是我们的代码不够严谨,需要修正代码的

重踏学习Java路上_Day26(网络编程)

1:网络编程(理解)    (1)网络编程:用Java语言实现计算机间数据的信息传递和资源共享    (2)网络编程模型    (3)网络编程的三要素        A:IP地址            a:点分十进制            b:IP地址的组成            c:IP地址的分类            d:dos命令            e:InetAddress        B:端口            是应用程序的标识.范围:0-65535.其中0-1024不建议使

重踏学习Java路上_Day20(递归,IO流)

1:递归(理解)     (1)方法定义中调用方法本身的现象        举例:老和尚给小和尚讲故事,我们学编程    (2)递归的注意事项:        A:要有出口,否则就是死递归        B:次数不能过多,否则内存溢出        C:构造方法不能递归使用    (3)递归的案例:        A:递归求阶乘        B:兔子问题        C:递归输出指定目录下所有指定后缀名的文件绝对路径        D:递归删除带内容的目录(小心使用) 2:IO流(掌握)  

重踏学习Java路上_Day14(正则表达式,Math,Random,System,BigInteger,BigDecimal,Date,Calendar)

1:正则表达式(理解)    (1)就是符合一定规则的字符串    (2)常见规则        A:字符            x 字符 x.举例:'a'表示字符a            \\ 反斜线字符.            \n 新行(换行)符 ('\u000A')             \r 回车符 ('\u000D')                    B:字符类            [abc] a.b 或 c(简单类)             [^abc] 任何字符,除了

重踏学习Java路上_Day18(Map,Collections)

1:Map(掌握) Map接口概述 将键映射到值的对象 一个映射不能包含重复的键 每个键最多只能映射到一个值 Map接口和Collection接口的不同 Map是双列的,Collection是单列的 Map的键唯一,Collection的子体系Set是唯一的 Map集合的数据结构值针对键有效,跟值无关   Collection集合的数据结构是针对元素有效    (3)Map接口功能概述(自己补齐)        A:添加功能        B:删除功能        C:判断功能        

重踏学习Java路上_Day12(Scanner,String)

1:Scanner的使用(了解)    (1)在JDK5以后出现的用于键盘录入数据的类.    (2)构造方法:        A:讲解了System.in这个东西.            它其实是标准的输入流,对应于键盘录入,in是System这个类中的最终静态变量:public static final InputStream;  in  “标准”输入流.此流已打开并准备提供输入数据.通常,此流对应于键盘输入或者由主机环境或用户指定的另一个输入源.        B:构造方法        

重踏学习Java路上_Day21(字符流,io小结,案例)

1:字符流(掌握)    (1)字节流操作中文数据不是特别的方便,所以就出现了转换流.       转换流的作用就是把字节流转换字符流来使用.    (2)转换流其实是一个字符流        字符流 = 字节流 + 编码表    (3)编码表        A:就是由字符和对应的数值组成的一张表        B:常见的编码表            ASCII            ISO-8859-1            GB2312            GBK            G