java oop 集合框架

集合主要是用来存放数据的，集合与数组的主要区别在于，集合的大小不受限制，而数组的大小受限制，在使用集合增加数据时又常常与泛型联系起来，所以集合和泛型在实际开发过程中总会结合在一起

数组致命的缺点是数组大小一旦确定，其大小将不在改变，集合可以认为是一种可变的数组，大小可以随着元素的增加而增加。

集合与数组具体的区别：

1.数组是一个线性序列，所以可以快速访问其他元素，当用户创建了一个数组时，其容量是不变的，而且在生命周期也是不能改变的，还有java数组会做边界检查，如果发现有越界现象，会报RuntimeException错误，所以不用担心和CC++一样不做边界检查而出现的问题

2.集合容量是可变的，扩展性比较好

3.集合的内部实现基于数组，所以数组的效率要高于集合

集合两大类：collection集合与map集合

List 结构集合类：

ArrayList类 LinkedList类 Vector类 Stack 类

Map结构集合类： HashMap Hashtable

Set集合类：HashSet TreeSet TreeSet 

Queue集合类：Queue接口

 1.ArrayList

List集合的子接口，允许集合存储元素可以重复，并可以将null存储在集合中，ArrayList实例都有一个默认容量，该容量用来存储数组元素的大小，并且ArrayList集合的长度可以自动增长

ArrayList是线程不安全的，如果有多个线程同时访问ArrayList，有可能出现访问数据不一致现象，因此使用ArrayList要结合线程加以同步

eg:

1.向ArrayList集合加元素

import java.util.ArrayList;
import java.util.List;
public class text3 {
public static void main(String[] args) {
    List lis=new ArrayList();
    lis.add("张无忌");
    lis.add("张无忌");
    lis.add("张无忌");
    lis.add(520);
    System.out.println(lis);
}
}

增加泛型后;

import java.util.ArrayList;
import java.util.List;

public class text3 {
    public static void main(String[] args) {
        List<String> lis = new ArrayList<String>();
//增加内容
        lis.add("张无忌");
        lis.add("张无忌");
        lis.add("张无忌");
        lis.add("张无忌");
        lis.add("wangzhi");
        System.out.println(lis);
    }
}

2.LinkedList

ArrayList 只能在尾部增加而不能在头部增加，LinkedList可以在集合的前后增加，LinkedList是线程不安全的，如果有多个线程同时访问一个链接列表，而其中至少一个线程从结构上修改了该列表，有可能造成集合访问不同步的情况发生

LinkedList增加元素

import java.util.ArrayList;
import java.util.List;
import java.util.LinkedList;
public class text3 {
    public static void main(String[] args) {
        LinkedList<String> lis=new LinkedList<String>();
        //增加元素
        lis.add("张三");
        lis.add("李四");
        lis.addFirst("王五");
        lis.addLast("赵六");
        System.out.println(lis);
    } 
}

3.HarshSet

该类实现Set接口，并且HashSet的顺序是不确定的，该类允许加入null元素，不允许集合添加重复元素，如果添加重复元素，将会覆盖之前的元素。HashSet是线程不同步的，如果多个线程同时访问一个HashSet,而其中至少一个线程修改了该集合，则可能造成数据访问不一致的情况发生

import java.util.HashSet;
import java.util.Set;
public class text3 {
    public static void main(String[] args) {
        Set<String> set=new HashSet<String>();
        //增加元素
        set.add("zhangsan");
        set.add("lisi");
        set.add("wangwu");
        set.add("wangwu");
        System.out.println(set);
    } 
}

4.TreeSet

用来集合元素内部排序使用的，TreeSet 集合是线程不同步的，

import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class text3 {
    public static void main(String[] args) {
//创建HashSet
          TreeSet ts = new TreeSet();
          // Add elements to the tree set
          ts.add("C");
          ts.add("A");
          ts.add("B");
          ts.add("E");
          ts.add("F");
          ts.add("D");
          ts.add("A");
          System.out.println(ts);
    
    }
    } 

 Comparable/comparable接口

主要用来对对象排序使用，这种排序称为自然排序，compareTo方法用户自己定义排序规则

int comparableTo(To) 比较次对象与指定对象的顺序，小于 等于 大于：负整数  0 正整数

实现Comparable接口的实体类：

 Person

package text3;

/**
 * 为了更好的实现排序功能，建议比较排序的类实现hashCode和equals方法
 * 
 * @author Administrator
 *
 */
public class Person implements Comparable<Person> {
    private String name;
    private int age;

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

    @Override
    public int hashCode() {
        final int prime = 31;//注意31
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;

        return true;
    }

    public String toString() {
        return name + "," + age;
    }

    @Override
    public int compareTo(Person o) {
        int c = age - o.age;
        if (c != 0)
            return c;
        return name.compareTo(o.getName());
    }

    // 自动调出
    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;
    }
}

Test

package text3;
import java.util.HashSet;
import java.util.Set;

public class Text {
public static void main(String[] args) {
    Set<Person> set=new HashSet<Person>();
    set.add(new Person("张三丰",20));
    set.add(new Person("张无忌",22));
    set.add(new Person("刘德华",31));
    set.add(new Person("王志",12));
    System.out.println(set);
}
}

增强for循环主要是用来打印集合的，并且增强for循环只能打印数组和泛型的集合，没有增强for循环之前，也可以用for来打印集合

使用for打印

import java.util.Set;
import java.util.List;
import java.util.ArrayList;
import java.util.HashSet;

public class Person{
    public static void main(String[] args) {
        printList();
        System.out.println("-------------------------------------------");
        printSet();
    }

    private static void printSet() {
        // TODO Auto-generated method stub
        Set<String> set=new HashSet<String>();
        set.add("张无忌");
        set.add("张学友");
        set.add("王志大帅哥");
        Object[] s=set.toArray();
        for(int i=0;i<s.length;i++) 
            System.out.println(s[i]);
    }

    private static void printList() {
        // TODO Auto-generated method stub
        List<String> lis=new ArrayList<String>();
        lis.add("张无忌");
        lis.add("张学友");
        lis.add("谢霆锋");
        lis.add("张柏芝");
        for(int i=0;i<lis.size();i++)
            System.out.println(lis.get(i));
    }
}

使用增强for循环

import java.util.Set;
import java.util.List;
import java.util.ArrayList;
import java.util.HashSet;

public class Person{
    public static void main(String[] args) {
        printList();
        System.out.println("-------------------------------------------");
        printSet();
    }

    private static void printSet() {
        // TODO Auto-generated method stub
        Set<String> set=new HashSet<String>();
        set.add("张无忌");
        set.add("张学友");
        set.add("王志大帅哥");
        for(String s:set){
            System.out.println(s);
        }
    }

    private static void printList() {
        // TODO Auto-generated method stub
        List<String> lis=new ArrayList<String>();
        lis.add("张无忌");
        lis.add("张学友");
        lis.add("谢霆锋");
        lis.add("张柏芝");
        for(String s:lis){
            System.out.println(s);
        }
}
    }

使用增强for循环可以很方便的打印集合，但增强for循环的局限性在于它只能打印集合中的内容，不能对集合本身进行修改，修改后会出现意想不到的情况，会报错

import java.util.Set;
import java.util.List;
import java.util.ArrayList;
import java.util.HashSet;

public class Person{
    public static void main(String[] args) {
        printList();
        System.out.println("-------------------------------------------");
        printSet();
    }

    private static void printSet() {
        // TODO Auto-generated method stub
        Set<String> set=new HashSet<String>();
        set.add("张无忌");
        set.add("张学友");
        set.add("王志大帅哥");
        for(String s:set){
            System.out.println(s);
        }
    }

    private static void printList() {
        // TODO Auto-generated method stub
        List<String> lis=new ArrayList<String>();
        lis.add("张无忌");
        lis.add("张学友");
        lis.add("谢霆锋");
        lis.add("张柏芝");
        for(String s:lis){
            System.out.println(s);
        }
}
    }

而使用普通for循环

package text4;
import java.util.List;
import java.util.ArrayList;
public class Hello {
public static void main(String[] args) {
    delList();
}
public static void delList(){
    //创建List实例化
    List<String> lis=new ArrayList<String>();
    //增加内容
    lis.add("张无忌");
    lis.add("张无忌");
    lis.add("刘德华");
    //删除
    for(int i=0;i<lis.size();i++){
        if("张无忌".equals(lis.get(i))){
            lis.remove(i);
        }
    }
    //打印
    for(String s:lis) System.out.println(s);
}

}

！！！有两个张无忌但是只删除了一个，解决方案

package text4;
import java.util.List;
import java.util.ArrayList;
public class Hello {
public static void main(String[] args) {
    delList();
}
public static void delList(){
    //创建List实例化
    List<String> lis=new ArrayList<String>();
    //增加内容
    lis.add("张无忌");
    lis.add("张无忌");
    lis.add("刘德华");
    //删除
    for(int i=0;i<lis.size();i++){
        if("张无忌".equals(lis.get(i))){
            lis.remove(i);
            i--;
        }
    }
    //打印
    for(String s:lis) System.out.println(s);
}

}

Iterator接口:

使用Iterator遍历集合

package text4;

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;
import java.util.HashSet;

public class Hello {
    public static void main(String[] args) {
        iteratorList();
        System.out.println("--------------------------------");
        iteratorSet();

    }

    public static void iteratorList() {
        // 创建实例化
        List<String> lis = new ArrayList<String>();
        lis.add("张无忌");
        lis.add("张无忌");
        lis.add("刘德华");
        System.out.println("删除前");
        System.out.println();
        // 获得iterator接口
        Iterator<String> it = lis.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
            if ("张无忌".equals(s)) {
                it.remove();
            }
        }
        System.out.println();
        System.out.println("删除后");
        // 删除
        for (String s : lis)
            System.out.println(s);
    }

    public static void iteratorSet() {
        // HashSet实例化
        Set<String> set = new HashSet<String>();
        set.add("张无忌");
        set.add("张无忌");
        set.add("张三丰");
        set.add("刘德华");
        // 获得Iterator接口
        Iterator it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

Map接口

 基于哈希表的Map接口的实现，Map可以存储键值，并允许使用null值和null键，Map接口不保证映射的顺序，Hashmap是线程不同步的，如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该印射，则它必须保持外部同步，主要用来存储 key_value数据

HashMap增加元素; 可重复当时会覆盖

package text4;

import java.util.Map;
import java.util.HashMap;

public class Hello {
    public static void main(String[] args) {
        add();
    }

    public static void add() {
        Map<String, String> map = new HashMap<String, String>();
        // 增加元素
        map.put("国家", "中国");
        map.put("老公", "小明");
        map.put("老婆", "小红");
        map.put("身份证", "123456");
        // 获取特定key对应的value
        String id = map.get("身份证");
        System.out.println(id);
    }
}

取出map中的所有的key值

package text4;

import java.util.Map;
import java.util.HashMap;
import java.util.Set;
//import java.util.keySet;
public class Hello {
    public static void main(String[] args) {
        add();
    }

    public static void add() {
        Map<String, String> map = new HashMap<String, String>();
        // 增加元素
        map.put("国家", "中国");
        map.put("老公", "小明");
        map.put("老婆", "小红");
        map.put("身份证", "123456");
        map.put("身份证", "421127199712241714");
        // 获取特定key对应的value
        String id = map.get("身份证");
        System.out.println(id);
        //取出所有的key值
        Set<String> keys=map.keySet();
        for(String s:keys){
            System.out.println(s);
        }
    }
}

获取集合中所有的value值

package text4;

import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.Collection;
//import java.util.keySet;
public class Hello {
    public static void main(String[] args) {
        add();
    }

    public static void add() {
        Map<String, String> map = new HashMap<String, String>();
        // 增加元素
        map.put("国家", "中国");
        map.put("老公", "小明");
        map.put("老婆", "小红");
        map.put("身份证", "123456");
        map.put("身份证", "421127199712241714");
        //取出所有的key值
        Set<String> keys=map.keySet();
        for(String s:keys){
            System.out.println(s);
        }
        System.out.println("-----------------------------------");
        //获取所有的value值
        Collection<String> cs=map.values();
        for(String s:cs) System.out.println(s);
        
    }
}

获取所有的key与value值

package text4;

import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.Collection;
//import java.util.keySet;
public class Hello {
    public static void main(String[] args) {
        add();
    }

    public static void add() {
        Map<String, String> map = new HashMap<String, String>();
        // 增加元素
        map.put("国家", "中国");
        map.put("老公", "小明");
        map.put("老婆", "小红");
        map.put("身份证", "123456");
        map.put("身份证", "421127199712241714");
        System.out.println("获取所有的key值");
        //取出所有的key值
        Set<String> keys=map.keySet();
        for(String s:keys){
            System.out.println(s);
        }
        System.out.println("-----------------------------------");
        System.out.println("获取所有的value值");
        //获取所有的value值
        Collection<String> cs=map.values();
        for(String s:cs) System.out.println(s);
        System.out.println("------------------------------------");
        System.out.println("获取所有的value与key值");
        //取出所有的value与key值
        Set<Map.Entry<String, String>> sets=map.entrySet();
        for(Map.Entry<String, String> s:sets){
            String key=s.getKey();
            String value=s.getValue();
            System.out.println(key+":"+value);
        }
    }
}

 容器选择原则;

综合案例：

A:职员管理系统：

package day4;

import java.util.*;
import java.io.*;
/**
 * @author qingfeng
 * 重要思想：面向对象思想（添加员工管理类）
 * 功能：公司职员薪水管理系统
 */
public class SalarySystem {

    public static void main(String[] args) throws IOException {
        
        ClerkManager cm = new ClerkManager();//创建员工管理类
        
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        
        while(true)
        {
            //简易菜单
            System.out.println("公司职员薪水管理系统");
            System.out.println("---------------------------------------");
            System.out.println("1.添加新员工");
            System.out.println("2.根据工号显示该员工的信息");
            System.out.println("3.显示所有员工信息");
            System.out.println("4.修改员工的薪水");
            System.out.println("5.根据工号删除该员工的信息");
            System.out.println("6.根据薪资由低到高排序");
            System.out.println("7.统计员工的平均工资、最高工资和最低工资");
            System.out.println("---------------------------------------");
            System.out.println("请选择序号：");
            
            String no = br.readLine();
            
            if(no.equals("1")){
                System.out.println("添加新员工：");
                System.out.println("请输入姓名:");
                String name = br.readLine();
                
                
                System.out.println("请输入性别:");
                String sex = br.readLine();
                
                System.out.println("请输入年龄:");//如何用InputStreamReader来输入一个int型的数据
                Scanner sc = new Scanner(System.in);
                int age = sc.nextInt();
                
                System.out.println("请输入工号:");
                String clerkNo = br.readLine();
                
                System.out.println("请输入薪资:");
                float salary = Float.parseFloat(br.readLine());
                
                Clerk clerk = new Clerk(name, sex, age, clerkNo, salary);//创建员工对象并且调用构造方法初始化
                cm.addClerk(clerk);//调用“添加新员工”方法
                
            }else if(no.equals("2")){
                System.out.println("请输入员工号:");
                String clerkNo = br.readLine();//接收输入的工号
                cm.showInfo(clerkNo);
                
            }else if(no.equals("3")){
                System.out.println("显示所有员工信息:");
                cm.showAllInfo();
                
            }else if(no.equals("4")){
                System.out.println("修改员工的薪水:");
                System.out.println("输入员工工号:");
                String clerkNo = br.readLine();//接收输入的工号
                System.out.println("修改员工薪资:");
                String sal = br.readLine();
                float salary = Float.parseFloat(sal);
                cm.modifySal(clerkNo, salary);
                
            }else if(no.equals("5")){
                System.out.println("根据工号删除该员工的信息:");
                System.out.println("输入员工工号:");
                String clerkNo = br.readLine();//接收输入的工号
                cm.deleteInfo(clerkNo);
                
            }else if(no.equals("6")){
                System.out.println("根据薪资由低到高排序");
                cm.Qsort(0, cm.al.size()-1);
                cm.showAllInfo();
            }else if(no.equals("7")){
                System.out.println("统计员工的平均工资、最高工资和最低工资:");
                cm.calSalary();
            }else if(no.equals("8")){
                System.exit(0);
            }else{
                System.out.println("输入不合法！");
            }
        }
                
        
    }
}
//员工管理类（非常重要！面向对象）
class ClerkManager
{
    //成员属性
    ArrayList al = null;
    
    //构造方法：初始化 不断创造新对象
    public ClerkManager()
    {
        al = new ArrayList();//注意写法！！
    }
    
    //成员方法
    //添加新员工!
    public void addClerk(Clerk clerk) //注意用增加的对象的引用作为参数！
    {
        al.add(clerk); //ArrayList添加方法用add()方法！
    }
    
    //根据工号显示该员工的信息
    public void showInfo(String no)
    {
        int flag = 0;
        for(int i=0; i<al.size(); i++)
        {
            Clerk clerk= (Clerk)al.get(i);
            if(clerk.getNo().equals(no))
            {
                flag = 1;
                System.out.println("clerk"+(i+1)+"的信息是：");
                System.out.print("姓名:"+clerk.getName());
                System.out.print("  性别:"+clerk.getSex());
                System.out.print("  年龄:"+clerk.getAge());
                System.out.print("  工号:"+clerk.getNo());
                System.out.println("  薪资:"+clerk.getSalary());
            }    
        }
        if(flag == 0)
            System.out.println("找不到所查工号！");
    }
    
    //显示所有员工信息
    public void  showAllInfo()
    {
        for(int i=0; i<al.size(); i++)
        {
            Clerk clerk= (Clerk)al.get(i);
            System.out.println("clerk"+(i+1)+"的信息是：");
            
            System.out.print("姓名:"+clerk.getName());
            System.out.print("  性别:"+clerk.getSex());
            System.out.print("  年龄:"+clerk.getAge());
            System.out.print("  工号:"+clerk.getNo());
            System.out.println("  薪资:"+clerk.getSalary());
        }
    }
    
    //修改员工的薪水
    public void  modifySal(String no, float sal) //员工编号   最新的薪资
    {
        int flag = 0;
        for(int i=0; i<al.size(); i++)
        {
            Clerk clerk= (Clerk)al.get(i);
            if(clerk.getNo().equals(no))
            {
                flag = 1;
                clerk.setSalary(sal);
            }    
        }
        if(flag == 0)
            System.out.println("找不到所查工号！");
    }

    //根据工号删除该员工的信息
    public void deleteInfo(String no)
    {
        int flag = 0;
        for(int i=0; i<al.size(); i++)
        {
            Clerk clerk= (Clerk)al.get(i);
            if(clerk.getNo().equals(no))
            {
                flag = 1;
                al.remove(i);
            }    
        }
        if(flag == 0)
            System.out.println("找不到所查工号！");
    }

    //根据薪资由低到高排序
    public void Qsort(int left, int right)
    {
        int i = left;
        int j = right;
        
        if(i < j)//递归结束条件
        {
            Clerk clerk = (Clerk)al.get(left);
            float key  = clerk.getSalary();
            while(i<j)//一趟快速排序
            {
                while(i<j && ((Clerk)al.get(j)).getSalary() >= key)
                {
                    j--;
                }
                if(i<j)
                {
                    al.set(i,al.get(j));
                    i++;
                }
                while(i<j && ((Clerk)al.get(i)).getSalary() <= key)
                {
                    i++;
                }
                if(i<j)
                {
                    al.set(j, al.get(i));
                }
            }
            al.set(i, clerk);
            Qsort(left, i-1);
            Qsort(i+1, right);
        }
    }

    //统计员工的平均工资、最高工资和最低工资
    public void calSalary()
    {
        float totalSal = 0;
        float minSal = ((Clerk)al.get(0)).getSalary();
        float maxSal = ((Clerk)al.get(0)).getSalary();
        
        for(int i=0; i<al.size(); i++)
        {
            Clerk clerk = (Clerk)al.get(i);
            totalSal += clerk.getSalary();
            if(minSal > clerk.getSalary())
            {
                minSal = clerk.getSalary();
            }
            if(maxSal < clerk.getSalary())
            {
                maxSal = clerk.getSalary();
            }
        }
        System.out.println(al.size()+"个人的平均薪资为：" + totalSal/al.size());
        System.out.println(al.size()+"个人的最低薪资为："+minSal);
        System.out.println(al.size()+"个人的最高薪资为："+maxSal);
    }
}
//员工类
class Clerk 
{
    private String name;
    private String sex;
    private int age;
    private String no;
    private float salary;
    
    public Clerk(String name, String sex, int age, String no, float salary) 
    {
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.no = no;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    public String getNo() {
        return no;
    }

    public void setNo(String no) {
        this.no = no;
    }

    public float getSalary() {
        return salary;
    }

    public void setSalary(float salary) {
        this.salary = salary;
    }
}

B.命令行贪吃蛇