AI 助理
备案控制台
开发者社区 数据库 文章 正文

[零基础学JAVA]Java SE应用部分-35.JAVA类集之二

2017-11-11 910
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
JAVA按以下重要顺序 
· 面向对象 
· 类集框架 
· JDBC 
· 文件编程
本季目标
主要讲解以下的内容： 
· Collection 
· List 
· Set 
· Map 
· Iterator 
· ListIteator 
· Enumeration 
· for…each语句（JDK 1.5的新特性） 
· Comparable接口 
· 二叉树
1、类集结构
（1）类集的产生目的
类集简单来讲就是一个动态的对象数组，此对象数组可以改变大小，可以任意的实现对象的增加、删除、输出。所有的类集存放java.util包中。
（2）类集的划分 
1、存放单值：Collection 
2、存放一对值：Map 
3、输出：Iterator
（3）类集的具体概念 
<1>Collection（只能存放一个值） 
|- 主要功能：用于输出使用 
|- 子接口：List（允许有重复的元素，而且加入的顺序就是输出的顺序） 
    |- 子类：ArrayList，是在Java 2之后推出的，是新的类，是使用异步处理方式，其性能较高 
    |- 子类：Vector，是在JDK 1.0的时候就推出，因为是旧的类，有很多List所没有的功能，是使用同步处理方式，其线程安全性较高，会比较慢。使用Vector除了可以使用Iterator输出之外，也可以使用Enumeration进行输出。两者是通用的。Vector子类允许直接使用 addElement(Object obj)，也是可以向集合中加入元素的。 
    |- 自己新增的方法： 
        |- 取每一个对象： public Object get(int ind) ; 
    |- 子类：Stack（栈） 
|- 子接口：Set（不允许有重复元素，重复元素会替换）？如何可以区分重复元素呢？  
    |- 子类：HashSet：是无序列存放 
    |- 子类：TreeSet：有序存放，是通过Comparable接口完成的 
|- 常用方法： 
    |- 增加一个对象： public boolean add(Object obj) 
    |- 取得类集的长度： public int size() ; 
    |- 判断集合中的内容是否为空： public boolean isEmpty() 
    |- 删除一个对象： public boolean remove(Object obj) ：就必须牵扯到对象的比较状态。 
    |- 实例化Iterator对象： public Iterator iterator() ; 
<2>JDK 1.5提供了一个方便的输出操作：for…each语句。 
<3>Iterator接口输出是最常见的 
|- 常用方法 
    |-  public boolean hasNext()：判断是否有下一个元素 
    |-  public Object next()：取出下一个元素 
|- 子接口：ListIterator，可以进行双向输出，只对于List接口有用 
    |- 常用方法：具备了Iterator接口中的全部内容 
        |-  public boolean hasPrevious() 
        |-  public Object previous()  
<4>Enumeration（在1.5之后也加入、泛型支持哈~） 
|- 常用方法： 
    |- 判断是否有下一个元素： public boolean hasMoreElements() 
    |- 取出元素： public Object element() 
5、 Map（存放一对值） 
|- 功能：与Collection的功能不一样，Map的主要功能是用于查找使用的。 
|- 注意点： 
    |- 使用Map操作时，不能直接使用Iterator进行输出。 
    |- 而且里面不能有重复key。 
    |- 如果非要使用Iterator进行输出，则必须按以下的步骤进行操作： 
|- Map --> Set --> Iterator --> Map.Entry --> key与value的分离 
|- 常用子类： 
    |- HashMap：无序存放，是新的类，是JDK 1.2时推出的，是异步处理，性能较高 
    |- Hashtable：是旧的类，是JDK 1.0时推出的，是线程安全的，性能较低 
        |- Properties（重点）：属性文件操作类 
    |- TreeMap：有序存放 
|- 常用方法： 
    |- 向集合中保存数据： public Object put(Object key,Object value)：返回的是value 
    |- 从集合中查找数据： public Object get(Object key)：根据key查找。 
    |- 将Map数据变为Set实例： Set<Map.Entry<K,V>> entrySet() 
    |- 将全部的key变为set实例： Set<K> keySet() 
    |- 将全部的vlaue变为Collection接口实例： Collection<V> values() 
|- Map.Entry：保存key与value 
    |-  public Object getKey() 
    |-  public Object getValue() 
|- 存放key的注意点：
################Michael分割线####################
2、代码讲解
（6）实例一 
例如，一个学校里有多个学生？问如何可以表现出关系
一对多哈，类似数据库
import java.util.*;    
class School{    
         private String name;    
         //一个学校有多个学生    
         private List<Student> allStudents;    
         public School(String name){    
                 this.setName(name);    
                 this.setAllStudents( new ArrayList<Student>());    
        }    
         //向学校中加入学生    
         public  void add(Student stu){    
                 this.allStudents.add(stu);    
        }    
         public  void setName(String name){    
                 this.name = name;    
        }    
         public String getName(){    
                 return  this.name;    
        }    
         public  void setAllStudents(List<Student> allStudents){    
                 this.allStudents = allStudents;    
        }    
         public List<Student> getAllStudents(){    
                 return  this.allStudents;    
        }    
}    
class Student{    
         private String name;    
         private  int age;    
         //一个学生属于一个学校    
         private School school;    
         public Student(String name, int age){    
                 this.setName(name);    
                 this.setAge(age);    
        }    
         public  void setName(String name){    
                 this.name = name;    
        }    
         public String getName(){    
                 return  this.name;    
        }    
         public  void setAge( int age){    
                 this.age = age;    
        }    
         public  int getAge(){    
                 return  this.age;    
        }    
         public  void setSchool(School school){    
                 this.school = school;    
        }    
         public School getSchool(){    
                 return  this.school;    
        }    
}    
public  class Demo11{    
         public  static  void main(String[] args){    
                School sch =  new School( "51cto");    
                Student stu1 =  new Student( "张三",20);    
                Student stu2 =  new Student( "李四",25);    
                Student stu3 =  new Student( "王五",23);    
                Student stu4 =  new Student( "赵六",28);    
                Student stu5 =  new Student( "孙七",35);    
                 //设置关系    
                sch.add(stu1);    
                stu1.setSchool(sch);    
                sch.add(stu2);    
                stu2.setSchool(sch);    
                sch.add(stu3);    
                stu3.setSchool(sch);    
                sch.add(stu4);    
                stu4.setSchool(sch);    
                sch.add(stu5);    
                stu5.setSchool(sch);    
                 //肯定此时可以从一个学校里打印出全部的学生信息    
                 //学生也可以清楚的知道自己属于哪一个学校    
                System.out.println( "学校名称："+sch.getName());    
                List<Student> all = sch.getAllStudents();    
                Iterator<Student> iter = all.iterator();    
                 while(iter.hasNext()){    
                        Student s = iter.next();    
                        System.out.println( "\t|- 学生姓名："+s.getName()+ "，年龄："+s.getAge());    
                }    
        }    
}
看下效果：
image
我们也可以通过学生查找学校信息哈~
import java.util.*;    
class School{    
         private String name;    
         //一个学校有多个学生    
         private List<Student> allStudents;    
         public School(String name){    
                 this.setName(name);    
                 this.setAllStudents( new ArrayList<Student>());    
        }    
         //向学校中加入学生    
         public  void add(Student stu){    
                 this.allStudents.add(stu);    
        }    
         public  void setName(String name){    
                 this.name = name;    
        }    
         public String getName(){    
                 return  this.name;    
        }    
         public  void setAllStudents(List<Student> allStudents){    
                 this.allStudents = allStudents;    
        }    
         public List<Student> getAllStudents(){    
                 return  this.allStudents;    
        }    
}    
class Student{    
         private String name;    
         private  int age;    
         //一个学生属于一个学校    
         private School school;    
         public Student(String name, int age){    
                 this.setName(name);    
                 this.setAge(age);    
        }    
         public  void setName(String name){    
                 this.name = name;    
        }    
         public String getName(){    
                 return  this.name;    
        }    
         public  void setAge( int age){    
                 this.age = age;    
        }    
         public  int getAge(){    
                 return  this.age;    
        }    
         public  void setSchool(School school){    
                 this.school = school;    
        }    
         public School getSchool(){    
                 return  this.school;    
        }    
}    
public  class Demo11{    
         public  static  void main(String[] args){    
                School sch =  new School( "51cto");    
                Student stu1 =  new Student( "张三",20);    
                Student stu2 =  new Student( "李四",25);    
                Student stu3 =  new Student( "王五",23);    
                Student stu4 =  new Student( "赵六",28);    
                Student stu5 =  new Student( "孙七",35);    
                 //设置关系    
                sch.add(stu1);    
                stu1.setSchool(sch);    
                sch.add(stu2);    
                stu2.setSchool(sch);    
                sch.add(stu3);    
                stu3.setSchool(sch);    
                sch.add(stu4);    
                stu4.setSchool(sch);    
                sch.add(stu5);    
                stu5.setSchool(sch);    
                 //肯定此时可以从一个学校里打印出全部的学生信息    
                 //学生也可以清楚的知道自己属于哪一个学校    
                System.out.println( "学校名称："+sch.getName());    
                List<Student> all = sch.getAllStudents();    
                Iterator<Student> iter = all.iterator();    
                 while(iter.hasNext()){    
                        Student s = iter.next();    
                        System.out.println( "\t|- 学生姓名："+s.getName()+ "，年龄："+s.getAge()+ "-->"+s.getSchool().getName());    
                }    
        }    
}
这是典型的双向关系模型哈~
image 
进一步扩展呢？一个学校有多个班级，一个班级有多个学生？
import java.util.*;    
class School{    
         private String name;    
         //一个学校有多个学生    
         private List<Cls> allClss;    
         public School(String name){    
                 this.setName(name);    
                 this.setAllClss( new ArrayList<Cls>());    
        }    
         //向学校中加入学生    
         public  void add(Cls cls){    
                 this.allClss.add(cls);    
        }    
         public  void setName(String name){    
                 this.name = name;    
        }    
         public String getName(){    
                 return  this.name;    
        }    
         public  void setAllClss(List<Cls> allClss){    
                 this.allClss = allClss;    
        }    
         public List<Cls> getAllClss(){    
                 return  this.allClss;    
        }    
}    
class Cls{    
         private String name;    
         private School school;    
         private List<Student> allStudents;    
         public Cls(String name){    
                 this.setName(name);    
                 this.setAllStudents( new ArrayList<Student>());    
        }    
         //向班级中加入学生    
         public  void add(Student stu){    
                 this.allStudents.add(stu);    
        }    
         public List<Student> getAllStudents(){    
                 return  this.allStudents;    
        }    
         public  void setAllStudents(List<Student> allStudents){    
                 this.allStudents = allStudents;    
        }    
         public  void setSchool(School school){    
                 this.school = school;    
        }    
         public School getSchool(){    
                 return  this.school;    
        }    
         public  void setName(String name){    
                 this.name = name;    
        }    
         public String getName(){    
                 return  this.name;    
        }    
}    
class Student{    
         private String name;    
         private  int age;    
         //一个学生属于一个学校    
         private Cls cls;    
         public Student(String name, int age){    
                 this.setName(name);    
                 this.setAge(age);    
        }    
         public  void setName(String name){    
                 this.name = name;    
        }    
         public String getName(){    
                 return  this.name;    
        }    
         public  void setAge( int age){    
                 this.age = age;    
        }    
         public  int getAge(){    
                 return  this.age;    
        }    
         public  void setCls(Cls cls){    
                 this.cls = cls;    
        }    
         public Cls getCls(){    
                 return  this.cls;    
        }    
}    
public  class Demo12{    
         public  static  void main(String[] args){    
                School sch =  new School( "51cto");    
                Cls c1 =  new Cls( "Java一班");    
                Cls c2 =  new Cls( "Java二班");    
                Cls c3 =  new Cls( "Java三班");    
                Student stu1 =  new Student( "张三",20);    
                Student stu2 =  new Student( "李四",25);    
                Student stu3 =  new Student( "王五",23);    
                Student stu4 =  new Student( "赵六",28);    
                Student stu5 =  new Student( "孙七",35);    
                 //设置关系    
                sch.add(c1);    
                c1.setSchool(sch);    
                sch.add(c2);    
                c2.setSchool(sch);    
                sch.add(c3);    
                c3.setSchool(sch);    
                c1.add(stu1);    
                stu1.setCls(c1);    
                c2.add(stu2);    
                stu2.setCls(c2);    
                c2.add(stu3);    
                stu3.setCls(c2);    
                c3.add(stu4);    
                stu4.setCls(c3);    
                c3.add(stu5);    
                stu5.setCls(c3);    
                 //如果要输出全部的内容，则肯定要进行双重循环    
                System.out.println( "学校名称："+sch.getName());    
                Iterator<Cls> iter1 = sch.getAllClss().iterator();    
                 while(iter1.hasNext()){    
                        Cls c = iter1.next();    
                        System.out.println( "\t|- 班级名称："+c.getName());    
                         //输出一个班级中的全部学生    
                        Iterator<Student> iter2 = c.getAllStudents().iterator();    
                         while(iter2.hasNext()){    
                                Student s = iter2.next();    
                                System.out.println( "\t\t|- 学生姓名："+s.getName()+ "，学生年龄："+s.getAge()+ " --> "+s.getCls().getSchool().getName());    
                        }    
                }    
        }    
}
看下效果：
image
（7）实例二 
例如有一种情况： 
一个学生可以选多门课程，一门课程允许有多个学生参加。
import java.util.*;    
class Student{    
         private String name;    
         private  int age;    
         //一个学生可以选多门课程    
         private List<Course> allCourses;    
         public Student(String name, int age){    
                 this.setName(name);    
                 this.setAge(age);    
                 this.setAllCourses( new ArrayList<Course>());    
        }    
         public  void add (Course course){    
                 this.allCourses.add(course);    
        }    
         public  void setName(String name){    
                 this.name = name;    
        }    
         public String getName(){    
                 return  this.name;    
        }    
         public  void setAge( int age){    
                 this.age = age;    
        }    
         public  int getAge(){    
                 return  this.age;    
        }    
         public  void setAllCourses(List<Course> allCourses){    
                 this.allCourses = allCourses;    
        }    
         public List<Course> getAllCourses(){    
                 return  this.allCourses;    
        }    
}    
class Course{    
         private String name;    
         private  float grade;    
         private List<Student> allStudents;    
         public Course(String name, float grade){    
                 this.setName(name);    
                 this.setGrade(grade);    
                 this.setAllStudents( new ArrayList<Student>());    
        }    
         public  void add(Student student){    
                 this.allStudents.add(student);    
        }    
         public  void setName(String name){    
                 this.name = name;    
        }    
         public  void setGrade( float grade){    
                 this.grade = grade;    
        }    
         public  void setAllStudents(List<Student> allStudents){    
                 this.allStudents = allStudents;    
        }    
         public String getName(){    
                 return  this.name;    
        }    
         public  float getGrade(){    
                 return  this.grade;    
        }    
         public List<Student> getAllStudents(){    
                 return  this.allStudents;    
        }    
}    
public  class Demo13{    
         public  static  void main(String[] args){    
                Student stu1 =  new Student( "张三",20);    
                Student stu2 =  new Student( "李四",25);    
                Student stu3 =  new Student( "王五",23);    
                Student stu4 =  new Student( "赵六",28);    
                Student stu5 =  new Student( "孙七",35);    
                Course c1 =  new Course( "JAVA SE 基础",2.0f);    
                Course c2 =  new Course( "JAVA EE WEB",3.0f);    
                Course c3 =  new Course( "分布式开发 ",5.0f);    
                 //设置关系    
                stu1.add(c1);    
                c1.add(stu1);    
                stu1.add(c2);    
                c2.add(stu1);    

                stu2.add(c2);    
                c2.add(stu2);    

                stu3.add(c1);    
                c1.add(stu3);    
                stu3.add(c2);    
                c2.add(stu3);    
                stu3.add(c3);    
                c3.add(stu3);    

                stu4.add(c3);    
                c3.add(stu4);    
                stu5.add(c3);    
                c3.add(stu5);    
                 //随便验证一个学生所选择的课程以及一门课程所参加的学生    
                System.out.println( "学生姓名："+stu1.getName());    
                Iterator<Course> iter1 = stu1.getAllCourses().iterator();    
                 while(iter1.hasNext()){    
                        Course c = iter1.next();    
                        System.out.println( "\t|- 课程名称："+c.getName()+ "，学分："+c.getGrade());    
                }    
                System.out.println( "课程名称："+c3.getName());    
                Iterator<Student> iter2 = c3.getAllStudents().iterator();    
                 while(iter2.hasNext()){    
                        Student s = iter2.next();    
                        System.out.println( "\t|- 学生姓名："+s.getName()+ "，学生年龄："+s.getAge());    
                }    
        }    
} 
看下效果：
image
#####################Michael分割线#########################






本文转自redking51CTO博客，原文链接：http://blog.51cto.com/redking/139795 ，如需转载请自行联系原作者
文章标签：
Java
安全
数据库
关键词：
Java应用
技术小美
目录
相关文章
阿里云云原生
|
2月前
|
人工智能 Java API
Java也能快速搭建AI应用？一文带你玩转Spring AI可落地性
Java语言凭借其成熟的生态与解决方案，特别是通过 Spring AI 框架，正迅速成为 AI 应用开发的新选择。本文将探讨如何利用 Spring AI Alibaba 构建在线聊天 AI 应用，并实现对其性能的全面可观测性。
阿里云云原生
617 15
vohelon
|
5月前
|
人工智能 安全 Java
Java和Python在企业中的应用情况
Java和Python在企业中的应用情况
vohelon
164 7
艾利克斯冰
|
5月前
|
JSON Java Apache
非常实用的Http应用框架，杜绝Java Http 接口对接繁琐编程
UniHttp 是一个声明式的 HTTP 接口对接框架，帮助开发者快速对接第三方 HTTP 接口。通过 @HttpApi 注解定义接口，使用 @GetHttpInterface 和 @PostHttpInterface 等注解配置请求方法和参数。支持自定义代理逻辑、全局请求参数、错误处理和连接池配置，提高代码的内聚性和可读性。
艾利克斯冰
336 3
技术小达人
|
1月前
|
人工智能 Java API
Java 也能快速搭建 AI 应用？一文带你玩转 Spring AI 可观测性
Java 也能快速搭建 AI 应用？一文带你玩转 Spring AI 可观测性
技术小达人
103 4
阿里云基础设施.
|
2月前
|
缓存 Java 物联网
CRaC技术助力ACS上的Java应用启动加速
容器计算服务借助ACS的柔性算力特性并搭配CRaC技术极致地提升Java类应用的启动速度。
阿里云基础设施.
50 0
技术内容小助手
|
2月前
|
人工智能 Java API
Java 也能快速搭建 AI 应用？一文带你玩转 Spring AI 可观测性
Java 也能快速搭建 AI 应用？一文带你玩转 Spring AI 可观测性
技术内容小助手
56 0
潜意识Java
|
3月前
|
Java 编译器 开发者
Java中的this关键字详解：深入理解与应用
本文深入解析了Java中`this`关键字的多种用法
潜意识Java
474 9
阿里云开发者
|
5月前
|
人工智能 前端开发 Java
基于开源框架Spring AI Alibaba快速构建Java应用
本文旨在帮助开发者快速掌握并应用 Spring AI Alibaba，提升基于 Java 的大模型应用开发效率和安全性。
阿里云开发者
941 54
基于开源框架Spring AI Alibaba快速构建Java应用
潜意识Java
|
3月前
|
Java 应用服务中间件 API
【潜意识Java】javaee中的SpringBoot在Java 开发中的应用与详细分析
本文介绍了 Spring Boot 的核心概念和使用场景，并通过一个实战项目演示了如何构建一个简单的 RESTful API。
潜意识Java
77 5
潜意识Java
|
3月前
|
人工智能 自然语言处理 搜索推荐
【潜意识Java】了解并详细分析Java与AIGC的结合应用和使用方式
本文介绍了如何将Java与AIGC（人工智能生成内容）技术结合，实现智能文本生成。
潜意识Java
341 5

热门文章

最新文章

  • 1
    Java版Manus实现来了，Spring AI Alibaba发布开源OpenManus实现
  • 2
    【源码】【Java并发】【ThreadLocal】适合中学者体质的ThreadLocal源码阅读
  • 3
    Java程序员在AI时代必会的技术：Spring AI
  • 4
    Minecraft配置文件参数说明（JAVA服务器篇）
  • 5
    GraalVM 24 正式发布阿里巴巴贡献重要特性 —— 支持 Java Agent 插桩
  • 6
    在Java环境下如何进行Redis数据库的操作
  • 7
    智慧班牌源码，采用Java + Spring Boot后端框架，搭配Vue2前端技术，支持SaaS云部署
  • 8
    深入理解Java浅拷贝与深拷贝
  • 9
    【Java并发】【ThreadLocal】适合初学体质的ThreadLocal
  • 10
    【源码】【Java并发】【AQS】从ReentrantLock、Semaphore、CutDownLunch、CyclicBarrier看AQS源码
  • 1
    6个Java 工具，轻松分析定位 JVM 问题 !
    33
  • 2
    【Java并发】【ConcurrentHashMap】适合初学体质的ConcurrentHashMap入门
    25
  • 3
    通义灵码 Rules 库合集来了，覆盖Java、TypeScript、Python、Go、JavaScript 等
    47
  • 4
    智慧工地源码，Java语言开发，微服务架构，支持分布式和集群部署，多端覆盖
    36
  • 5
    Java 类和对象
    20
  • 6
    【Java并发】【原子类】适合初学体质的原子类入门
    40
  • 7
    【源码】【Java并发】【LinkedBlockingQueue】适合中学体质的LinkedBlockingQueue入门
    34
  • 8
    【Java并发】【LinkedBlockingQueue】适合初学体质的LinkedBlockingQueue入门
    29
  • 9
    java实现队列数据结构代码详解
    32
  • 10
    java动态代理
    41

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云oss简介和使用流程