常用的集合

集合的由来

* 处理多个相同数据我们采用数组，但是数组空间固定不能动态增长，插入或删除元素麻烦，所以我们使用集合处理这个问题
* 集合特点：元素类型可以不同，集合长度可以改变，空间不固定
* JAVA中对一些数据结构和算法进行了封装即集合。集合也是一种对象，用于储存，检索，操作，传输对象
* JCF(Java Collections Framework)集合框架。他提供了用于管理集合的接口 和类
* JCF包含接口，实现类，算法三种
* 集合框架在util工具包中

集合框架接口特性

* List：线性，元素顺序放置，所以元素可以重复   Arraylist数据列表实现类实现类常用
* Set：元素不可以重复放置
* Map：以键值对方式放置元素，一个元素放两个对象，键不能重复

集合中的算法
Interator (迭代器) 和Colletions 算法类，也util中
List代码演示

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

import javax.swing.JFrame;

public class ArraylistTest {

      public static void main(String[] args) {
            // 创建以list接口的ArrayList数组实现类
            List list=new ArrayList();
            //追加元素,元素类型不同
            list.add("abc");
            list.add(new JFrame());
            list.add(new Date());

            //Object所有类的父类，所以做参数可以接受任何子类对象
            for(Object obj:list){
                  System.out.println(obj);

            }

      }

}

集合的取值

public class Studnets {
      private String name;
      private String address;
      private String sex;


      public Studnets() {
            super();
            // TODO Auto-generated constructor stub
      }

      public Studnets(String name, String address, String sex) {
            //构造器可以直接初始化私有变量给其赋值
            super();
            this.name = name;
            this.address = address;
            this.sex = sex;
      }

      @Override
      public String toString() {
            return "Studnets [name=" + name + ", address=" + address + ", sex=" + sex + "]";
      }
      public String getName() {
            return name;
      }
      public void setName(String name) {
            this.name = name;
      }
      public String getAddress() {
            return address;
      }
      public void setAddress(String address) {
            this.address = address;
      }
      public String getSex() {
            return sex;
      }
      public void setSex(String sex) {
            this.sex = sex;
      }

}

三种取值方式，添加，修改，删除集合方法

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

public class ArraylistTest {

      public static void main(String[] args) {

            // <>为泛型，现在此集合只能添加学生类型
            List<Studnets> list = new ArrayList<Studnets>();
            list.add(new Studnets("张三", "红瓦寺", "男"));
            list.add(new Studnets("李四", "红星路", "女"));
            list.add(new Studnets("李伍", "红星路", "男"));

            //删除集合元素 remove(指定下标)；
            list.remove(1);
            //修改指定下标集合的元素，先取出元素的地址，修改对应地址的值
            Studnets st=list.get(1);
            st.setAddress("磨子桥");

            // size()表示得到集合的长度
            System.out.println(list.size());

            // for 循环取值，只适用于List集合
            for (int i = 0; i < list.size(); i++) {
                  // get表示获得
                  Studnets s = list.get(i);
                  System.out.println(s);
            }
            // for each循环取值
            for (Studnets s : list) {
                  System.out.println(s);
            }
            //迭代器
            Iterator<Studnets> it =list.iterator();
            while(it.hasNext()){//判断是否有下一个元素
                  Studnets y=it.next();//取出下一个元素
                  System.out.println(y);
            }

      }

}

set代码演示

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetTest {

      public static void main(String[] args) {
//          //创建set集合，其特点为元素不能重复,用Hash去接受，
//          Set<String> set=new HashSet<String>();
//          //创建一个set集合，用Tree去接受，会去掉重复并按照顺序排序
//          Set<Integer> set1=new TreeSet<Integer>();

            //set集会不会有重复
            Set<Studnets> set=new HashSet<Studnets>();
            Studnets sa=new Studnets("张三", "红瓦寺", "男");
            set.add(sa);
            set.add(sa);
            set.add(sa);
            for(Studnets s1:set){
                  System.out.println(s1);
            }

      }

}

map集合代码演示

Map<String, Studnets> map=new HashMap<String, Studnets>();
            //追加元素，map集合中一个元素有两个对象
            map.put("张三", new Studnets("张三","红星路","男"));
            map.put("李四", new Studnets("李四","红瓦寺","女"));
            map.put("王二", new Studnets("王二","磨子桥","男"));
            //map可以根据键对象，找到值对象，如果键对象不存在，返回空,Map集合键不能重复，如果重复，则替换
            Studnets s=map.get("李四");
            System.out.println(s);
            //判断指定键对应的元素是否存在
            System.out.println(map.containsKey("李四"));
            //删除建“李四”对应的元素
            map.remove("李四");
            //得到Map集合中键的集合
            Set<String> set=map.keySet();
            for(String key: set){
                  //根据键得到值
                  Studnets sd=map.get(key);
                  System.out.println("键："+key+"值："+sd);
            }

集合的排序

List<ProductBean> list= new ArrayList<ProductBean>();
            list.add(new ProductBean(1,"燕窝",2000,"海南岛"));
            list.add(new ProductBean(3,"熊掌",2500,"长白山"));
            list.add(new ProductBean(2,"鹿茸",4500,"西藏"));
            //Comparator为比较器，参数该接口的实现类后，在compare描述规则
            Collections.sort(list,new Comparator<ProductBean>() {

                  @Override
                  public int compare(ProductBean o1, ProductBean o2) {
                        // 描述规则，大返回正数，小返回负数，等于是正数，
                        return o1.getPrice()-o2.getPrice();
                  }
            });
            for(ProductBean p:list){
                  System.out.println(p);
            }

            //乱序，将集合元素随机排列
            Collections.shuffle(list);

泛型<>
泛型不是集合所特有的，定义类，也可以用到泛型规定他的类型

public class MyTest<T> {

      public T getT(){
            return null;
      }

      public static void main(String[] args) {
            MyTest<String> m=new MyTest<String>();

      }

}