自己做的点笔记,希望对大家有用
一.集合基本信息
集合(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);
}
}