JAVA中的集合

集合：储存多个同类型的元素一.Collection接口

常用的方法：

boolean add(E e); //新增

boolean isEmpty(); //是否集合是否为空

boolean contains(E e); //是否包含某个元素

boolean remove(E e); //删除某个元素

void clear(); //清除

int size()； //获取元素个数

       Collection c = new ArrayList<>();
	   //增加元素是否成功
	   boolean b= c.add("张三");
	   System.out.println(b); //true
	   //删除元素
	   boolean o =c.remove("张三");
	   System.out.println(o);  //true
	   //判断集合有没有元素,有元素false，没有元素true
	   boolean v = c.isEmpty();
	   System.out.println(v);  //true
	   //是否包含某个元素
	   v = c.contains("张三");
	   System.out.println(v);  //false
	   //获取集合中的元素个数
	   int n = c.size();
	   System.out.println(n); //0
	   //清除集合中元素
	     c.clear();
	   System.out.println(c); //[]

Iterator迭代器

注意事项：

通过迭代器遍历集合的失败，不能通过集合对象增删元素

如果删除可以通过迭代器删除方法删除

方法：

1.获取迭代器对象

Iterator 变量名= 集合对象.iterator( );

2.判断是否有元素

boolean hasNext( ); //有为true,没有为false

3.获取下一个元素

E next( );

4.获取谁删除谁

void remove( );

     Collection c = new ArrayList<>();
	  c.add("张三");
	  c.add("李四");
	  c.add("王麻子");
	  c.add("王柳");
	  c.add("小明");
	  
	  //获取迭代器对象
	  Iterator b = c.iterator();
	  //获取下一个元素
	  String name = b.next();
	  System.out.println(name); //张三
	  //判断是否有元素,有为true,没有为false
	  boolean v = b.hasNext();
	  System.out.println(v); //true
	  //删除元素
	  b.remove();
	  System.out.println(c); //[李四, 王麻子, 王柳, 小明]

使用迭代器遍历集合操作：

      Collection c = new ArrayList<>();
	  c.add("张三");
	  c.add("李四");
	  c.add("王麻子");
	  c.add("王柳");
	  c.add("小明");
	  
	  //获取迭代器对象
	  Iterator b = c.iterator();
	  while(b.hasNext()) {
		  String name = b.next();
		  System.out.println(name);  //张三 李四 王麻子 王柳 小明
	  }

增强for循环：

遍历集合的时候，底层就是迭代器

格式：

for (数据类型变量名：集合名){

//数据类型：集合的泛型

}

      Collection c = new ArrayList<>();
	  c.add("张三");
	  c.add("李四");
	  c.add("王麻子");
	  c.add("王柳");
	  c.add("小明");  
	  
	  //增强for循环遍历集合
	  for (String name : c) {
		System.out.println(name);  // 张三 李四 王麻子 王柳 小明
	}

二. List集合：

特点：有索引值，可以重复，有序的

常用方法：

void add( int index, E e) ; //给指定索引值位置添加元素

E get(int index) ; //获取index位置的元素。

E remove(int index); //移除index位置的元素, 返回的是否被删除的元素。

E set(int index, E e); //index位置元素替换

List subList (int beginIndex , int enIndex); //左闭右开取值

int indexOf (object o); //返回第一次出现索引值位置，参数传入要找的元素

int lastIndexOf (object o); //最后一次出现的索引值位置，如果该元素不存在则返回 -1

    //创建list集合对象
	List list =new  ArrayList<>();
	//添加元素
	list.add("aaa");
	list.add("bbb");
	list.add("ccc");
	list.add("ddd");
	
	
	//根据索引值，添加新元素
	list.add(0, "eeee");
	System.out.println(list); //[eeee, aaa, bbb, ccc, ddd]
	//删除元素，根据索引值
	String remove=list.remove(0);
	System.out.println("被删除元素是"+remove);  //eeee
	System.out.println(list); //[aaa, bbb, ccc, ddd]
	
	
	//根据索引值，获取集合中对应的元素
	String b = list.get(0);
	System.out.println(b); // aaa
	//把索引值对应元素替换
	String n =list.set(0, "hhhh");
	System.out.println("被替换的元素是："+n); //aaa
	System.out.println(list);  //[hhhh, bbb, ccc, ddd]
    //根据索引值从开始到结束的值（左闭右开）
	List list2 =list.subList(1,3);
	System.out.println(list2);  //[bbb, ccc]

三. ArrayList集合

概况：底层是数组

特点：查询快，增删慢

所属包： java.util

构造方法： public ArrayList();

成员方法：

boolean add(E e); //返回新增是否成功

E get( int index); //

E remove( int index); //根据索引值删除元素，返回被删除元素

boolean remove( object obj); //参数中传入要被删除的元素，删除是否成功

int size ( ); //获取元素个数

int indexOf( object obj); //返回第一次出现索引值位置，参数传入要找的元素

int lastIndexOf( object obj); //最后一次出现的索引值位置，如果该元素不存在则返回 -1

boolean contains(object obj); //是否包含某个元素

E set (int index , E e); //把参数index位置元素替换为参数e,则返回被替换元素

    //创建ArrayList集合对象
	ArrayList array = new ArrayList<>();
	//添加元素
	array.add("小王");
	array.add("小明");
	array.add("小红");
	array.add("小花");
	array.add("小花");
	array.add("小明");
	
	
	//根据索引值获取元素
	String name = array.get(0);
	System.out.println(name);//小王
	//根据索引值删除元素
	name =array.remove(1);
	System.out.println(name); //小明
	
	
	//参数中传入要删除元素，是否删除成功
	boolean c = array.remove("小王");
	System.out.println(c);//true
	//获取集合中元素个数
	int a = array.size();
	System.out.println(a); //2
	
	
	//判断是否包含牧歌元素
	c = array.contains("小明");
	System.out.println(c); //false
	//把参数位置元素替换成别
	String s = array.set(0, "张三");
	System.out.println("被替换的元素是："+s); //被替换的元素是：小红
	//返回第一次出现索引值位置
	a=array.indexOf("小花");
	System.out.println(a); //小花第一次出现的索引值位置
	//返回最后一次出现索引值位置
	a=array.lastIndexOf("小花");
	System.out.println(a); //小花最后一次出现的索引值位置

四. LinkedList

概括：底层是双向链表

特点：查询慢，增删快

常用方法：

void addFirst(E e) ; //将指定元素插入此列表的开头。

void addLast(E e) ; //将指定元素添加到此列表的结尾。

E getFirst( ) ; //返回此列表的第一个元素。

E getLast( ) ; //返回此列表的最后一个元素。

E removeFirst( ) ; //移除并返回此列表的第一个元素。

E removeLast( ) ; //移除并返回此列表的最后一个元素。

     //创建LinkedList集合对象
	LinkedList linked = new LinkedList<>();
	linked.add("aaa");
	linked.add("bbb");
	linked.add("ccc");
	linked.add("ddd");
	
	//将指定元素插入此列表的开头
	linked.addFirst("张三");
	System.out.println(linked);//[张三, aaa, bbb, ccc, ddd]
	//将指定元素添加到此列表的结尾。
	linked.addLast("李四");
	System.out.println(linked);//[张三, aaa, bbb, ccc, ddd, 李四]
	
	
	//返回此列表的第一个元素。
	String me =linked.getFirst();
	System.out.println(me); //张三
	//返回此列表的最后一个元素
	me=linked.getLast();
	System.out.println(me);//李四
	
	
	//移除并返回此列表的第一个元素
	String name = linked.removeFirst();
	System.out.println(name);//张三
	//移除并返回此列表的最后一个元素
	name=linked.removeLast();
	System.out.println(name);//李四

五：Vector集合

Vector集合: 效率低，线程安全

ArrayList集合: 线程不安全，效率高

六.Set集合

特点：没有索引值，不能重复

Set新增过程：

1.计算新增元素的哈希值(十进制的地址值)，调用H安世凑得();

2.通过哈希值%数组长度，去确定元素新增的索引值

如果该位置有元素：判断这两元素是否相同

如果不相同：挂到最后一个元素下面

如果相同：不新增

判断是否相同的标准：

比较哈希值相同 && （地址值相同 || equals相同）

总结：如果自定义类型对象，我们希望添加到HashSet集合中

我们认为成员变量的值相同，就同一个元素

则需要覆盖重写hashcode和equals方法

常用实现类：

1.HashSet：所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)

2.LinkedHashset: 有序，结构：链表+哈希表

3.TreeSet: 红黑树（可排序）

构造方法：

public TreeSet ( );

public TreeSet (c omparator < > c)

七.Collections类

集合工具类方法：

static boolean addAll (Collections c, T......array);

//用于所有指定元素添加到指定的集合

static viod shuffle(List list); //将List中的内容随机打乱顺序

static extends Comparaable void sort(List list);

// 对象进行排序,覆盖重写Comparator接口的compare方法

static void sort (List list,comparator c);

//对象进行排序，那么该类需要实现Comparable接口覆盖重写compartor()方法


        List list = new ArrayList<>();
		//用于所有指定元素添加到指定的集合
		Collections.addAll(list, "aaa","bbb","ccc","ddd");
		System.out.println(list); //[aaa, bbb, ccc, ddd]
		//将List中的内容随机打乱顺序
		Collections.shuffle(list);
		System.out.println(list);//[ddd, ccc, aaa, bbb]

八.Map集合

特点：

1. 一个元素key和value两部分

2.key和value可以是任意类型

3.key不能重复(底层是Set集合),一个key对应一个唯一的value

常用实现类：

HashMap: 底层是哈希表，无序

LinkeddHashMap: 底层是链表+哈希表，有序

TreeMap: 底层是红黑树，可排序

常用的方法：

v put(k k,v v); //添加元素

v remove(Object key): //按照指定的Key删除整个元素

void clear: //清空

v get(Object key): //获取指定key的value值。若无此key，则返回null。

boolean containsKey(object key);

boolean containsValue(object value);

int size(); //获取元素个数

boolean isEmpty( ); //判断集合是否为空

     //创建Map集合对象
	 Map  map = new HashMap<>();
	 //添加元素
	 map.put("张三", 25);
	 map.put("李四", 30);
	 map.put("小明", 50);
	 map.put("小花", 19);
	 System.out.println(map);//{李四=30, 张三=25, 小明=50, 小花=19}
	 
	 
	 //获取元素个数
	 int size = map.size();
	 System.out.println(size);//4
	 //删除某个元素,根据key删除整个元素,返回是Value值
	 Integer v = map.remove("张三");
	 System.out.println(map); //{李四=30, 小明=50, 小花=19}
	 //根据key值,获取value的值
	 v = map.get("李四");
	 System.out.println(v); //30
	
	
	 //判断key值是否此存在
	 boolean c = map.containsKey("李四");
	 System.out.println(c);//true
	 //判断value值是否存在
	 c = map.containsValue(50);
	 System.out.println(c); //true
	 
	 
	 //判断集合是否为空
	 c = map.isEmpty();
	 System.out.println(c);//false
	 //清空元素
	 map.clear();
	 System.out.println(map);//{}

Set keyset( ); //获取所有k值

Collection values ( ); //获取所有value值

    //创建Map集合对象
	Map  map = new HashMap<>();
	 //添加元素
	 map.put("张三", 25);
	 map.put("李四", 30);
	 map.put("小明", 50);
	 map.put("小花", 19);
	 
	 //获取所有K值
	Set a=map.keySet();
	System.out.println(a);//[李四, 张三, 小明, 小花]
	//获取所V的值
	Collection c =map.values();
	System.out.println(c);//[25，30，50，19]

JAVA中的集合

Java相关栏目本月热门文章