Java关于集合的操作

一.java 关于集合的一些操作
下面是一些操作集合的方法
add()将元素插入到指定位置的 arraylist 中、
addAll()添加集合中的所有元素到 arraylist 中、
clear()删除 arraylist 中的所有元素、
clone()复制一份 array、
listcontains()判断元素是否在、
arraylistget()通过索引值获取arraylist 中的元素、
indexOf()返回 arraylist 中元素的索引值、
removeAll()删除存在于指定集合中的 arraylist 里的所有元素、
remove()删除 arraylist 里的单个元素、
size()返回 arraylist 里元素数量、
isEmpty()判断 arraylist 是否为空、
subList()截取部分 arraylist 的元素、
set()替换 arraylist 中指定索引的元素、
sort()对 arraylist 元素进行排序、
toArray()将 arraylist 转换为数组、
toString()将 arraylist 转换为字符串、
ensureCapacity()设置指定容量大小的 、
arraylistlastIndexOf()返回指定元素在 arraylist 中最后一次出现的位置、retainAll()保留 arraylist 中在指定集合中也存在的那些元素、
containsAll()查看 arraylist 是否包含指定集合中的所有元素、
trimToSize()将 arraylist 中的容量调整为数组中的元素个数、
removeRange()删除 arraylist 中指定索引之间存在的元素、
replaceAll()将给定的操作内容替换掉数组中每一个元素、
removeIf()删除所有满足特定条件的 arraylist 元素、
forEach()遍历 arraylist 中每一个元素并执行特定操作

下面 是对集合的操作
集合（collection），collection是一个接口，其有两个子接口 list与set

List 可重复集

Set 不可重复集

// boolean contains(Object o)

//查看当前集合中是否包含给定的元素o

boolean a = list.contains(o) //返回boolean类型值

// boolean containsAll(connection list)

//查看当前集合中是否包含给定的集合元素

boolean a = list.containsAll(list1)

//addAll()方法将集合添加至另外一个集合类，返回类型boolean

list1.addAll(list2);

//获取集合的元素个数

int a = list.size();

//查看集合中是否不包含任何元素

boolean a = list.isEmpty();

//清空集合

list.clear();

//删除给定元素 返回boolean

list.remove(Object o);

二.list集合
ArrayList:更适合于访问，底层数组实现

LinkedList:更适合于插入和删除，底层链表实现

//subList(int start,int end) 获取当前集合中的子集

//修改子集的任何一个元素都会影响原集合

list.subList(1,5);

//toArray(); 将集合转换成数组

String[] arr = list.toArray(new String[ list.size() ] );

//asList(); 数组转List集合

注：通过asList转换的list不可以进行添加修改操作，只能用于查看

String[] arr = {‘1’,‘2’,‘3’,‘4’,‘5’,‘6’,‘7’};

List list = Arrays.asList(arr);

//list集排序方法 --从小到大

注：使用Collections的sort方法进行排序的集合，

要求元素必须实现Comparable接口，只有实现了

该接口才认为是比较的元素

实现compareTo()方法

比较大小的方法

返回值不关注具体的值，只关注取值范围

返回值<0 ：当前对象比给定的对象小

返回值=0 ：两个对象相等

返回值>0 ：当前对象比给定的对象大

public int compareTo(Object o){

return 定义比较规则返回

}

Collections.sort(list);

何时应该声明比较器

当集合中的元素已经实现了Comparable接口，并且实现了比较规则，但是该比较规则不能满足我们对于排序的需求

时，我们可以额外的声明一个比较规则。

xxx x = new xxx();

Collections.sort(list,x);

class xxx名 implements Comparator{

public int compare(String s1,String s2){

return s1.length()-s2.length();

}

}

可以使用匿名内部类

Comparator x = new Comparator(){

public int compare(String s1,String s2){

return s1.length()-s2.length();

}

}

//list集去重复

        List<String> lst1=new ArrayList<>();
        lst1.add("aa");
        lst1.add("dd");
        lst1.add("ss");
        lst1.add("aa");
        lst1.add("ss");

               //方法 1.
        for (int i = 0; i <lst1.size()-1; i++) {
            for (int j = lst1.size()-1; j >i; j--) {
                if (lst1.get(j).equals(lst1.get(i))) {
                    lst1.remove(j);
                }
            }
        }
        System.out.println(lst1);
         
               //方法 2.
        List<String> lst2=new ArrayList<>();
        for (String s:lst1) {
            if (Collections.frequency(lst2, s)<1) {
                lst2.add(s);
            }
        }
        System.out.println(lst2);

三.map集合
package JavaSE;

import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class JiHe02 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put(“A”, “1”);
map.put(“B”, “2”);
map.put(“C”, “3”);
map.put(“D”, “4”);
map.put(“E”, “5”);

 /*
  * 遍历所有的key
  * Set<K> keySet()
  * 该方法可以获取map中所有的key，并将它们存入一个
  * Set集合中返回
  * hashmap本身是无序key不可重复，Set集合也是
  */
 Set<String> keySet = map.keySet();
 for (String key : keySet) {
   System.out.println(key);
 }

 /*
  * 遍历键值对
  * Set<Entry> entrySet()
  * 该方法会将每一组key-value存入一个Entry实例中，
  * 并将这些Entry实例存入一个Set集合并返回
  * 我们只需要遍历该集合，拿到每一个Entry实例并获取其
  * 中的key与value即可
  */
 Set<Entry<String, String>> entrySet = map.entrySet();
 for (Entry<String, String> entry : entrySet) {
   String key = entry.getKey();
   String value = entry.getValue();
   System.out.println("key="+key+"  value="+value);
 }

 /*
  * 遍历所有的value
  */
 Collection<String> values = map.values();
 for (String val : values) {
   System.out.println(val);
 }

 //如果需要保证顺序，可以使用LinkedHashMap();    很少使用

}
}

四.迭代器iterator()
package JavaSE;

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

public class JiHe {

public static void main(String[] args) {

 //用迭代器遍历集合
 List<String> list = new ArrayList<String>();
 list.add("1");
 list.add("##");
 list.add("2");
 list.add("##");
 list.add("3");
 list.add("##");
 list.add("4");
 list.add("##");
 list.add("5");

 //建立迭代器实例
 Iterator<String> it = list.iterator();
 //it.hasNext() 询问迭代器，遍历的集合是否还有元素可取
 while (it.hasNext()) {
  
   String a = it.next();
   System.out.println(a);
  
   if ("##".equals(a)) {
     /*
      * 在使用迭代器遍历集合的过程中
      * 不可以通过集合的相关方法改变
      * 集合元素
      *
      * list.remove(a);
      */
    
     /*
      * 迭代器的remove方法用来从集合
      * 中删除刚刚next()出来的元素
      */
     it.remove();
    
   }
 }

 System.out.println(list);

}
}
五.队列
package JavaSE;

import java.util.LinkedList;
import java.util.Queue;

/**

• 队列
• 保存一组数据，存取元素必须遵循先进先出原则
• FIFO (First Input First Output)
• @author administrator

*/
public class JiHeDL {
public static void main(String[] args) {
Queue queue = new LinkedList();

 /*boolean offer();
 入队方法，将给定元素添加到队列末尾。添加成功返回true*/
 queue.offer("A");
 queue.offer("B");
 queue.offer("C");
 queue.offer("D");
 System.out.println(queue);

 /*poll();
 用于获取首元素。出队操作
 获取后，队列中将不包含该元素*/
 String str = queue.poll();
 System.out.println(str);
 System.out.println(queue);

 /*peek();
 用于获取队首元素，仅引用，不做出队操作*/
 String str1 = queue.peek();
 System.out.println(str1);
 System.out.println(queue);

 /*遍历队列
 遍历队列是一次性的*/
 while (queue.size()>0) {
   String que = queue.poll();
   System.out.println(que);
 }
 System.out.println(queue);

}
}
六.双端队列（栈）
package JavaSE;

import java.util.Deque;
import java.util.LinkedList;

/**

• 栈（双端队列Deque两端可进去，限制一端，只从
• 一端进出形成 -栈- 的形式 ）
• 用于存储一组数据，存取元素必须遵循先进后出原则
• 通常记录一组数据可追溯
• @author administrator

*/
public class JiHeDL01 {

public static void main(String[] args) {
Deque stack = new LinkedList();
/*
* void push(T t)
* 向栈顶“压入”一个元素——————入栈操作
*/
stack.push(“A”);
stack.push(“B”);
stack.push(“C”);
stack.push(“D”);
stack.push(“E”);
System.out.println(stack);

 /*
  * T pop()
  * 取出栈顶元素，出栈操作
  * 取出后，该元素会从栈中删除
  */
 String str = stack.pop();
 System.out.println(str);
 System.out.println(stack);

 /*
  * peek()
  * 获得栈顶元素，不会删除该元素
  */
 str = stack.peek();
 System.out.println(str);
 System.out.println(stack);

 /*
  * 同样的，遍历栈也是一次性的
  */
 while (stack.size()>0) {
   str = stack.pop();
   System.out.println(str);
 }
 System.out.println(stack);

}
}