自己做的点笔记,希望对大家有用

一.集合基本信息

集合（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<String> list = Arrays.asList(arr);

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

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

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

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

实现compareTo()方法

比较大小的方法

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

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

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

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

public int compareTo(Object o){

return 定义比较规则返回

}

Collections.sort(list);

何时应该声明比较器

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

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

xxx<String> x = new xxx();

Collections.sort(list,x);

class xxx名 implements Comparator<String>{

public int compare(String s1,String s2){

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

}

可以使用匿名内部类

Comparator x = new Comparator<String>(){

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();    很少使用
    
    
  }
}

四.迭代器

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<String> queue = new LinkedList<String>();
    
     /*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<String> stack = new LinkedList<String>();
     /*
      * 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);
    
  }
}

集合常用方法合集