Java集合

最新推荐文章于 2023-10-01 16:08:07 发布

impossiblezZ

最新推荐文章于 2023-10-01 16:08:07 发布

阅读量158

点赞数

文章标签： java

本文链接：https://blog.csdn.net/impossiblezZ/article/details/108191017

版权

一、泛型Generics


public class TestGenerics {
	public static void main(String[] args) {
		MyCollection<String>mc = new MyCollection<String>();
		mc.setObjects("aaa", 0);
		mc.setObjects("bbb", 1);
		String str = mc.getObjects(1);//增加了泛型，直接返回String类型，不用强转
		System.out.println(str);
		
	}
}
class MyCollection <E>{//E:表示泛型
	Object[] objects = new Object[5];
	
	public E getObjects(int index) {
		return (E) objects[index];
	}
	public void setObjects(E e,int index) {
		objects[index] = e;
	}
}

List的特点和常用方法

有序：List中每个元素都有索引标记。可以根据元素的索引标记(在List中的位置)访问元素，从而精确控制这些元素。

可重复：List允许加入重复的元素。更确切地讲，List通常允许满足 e1.equals(e2) 的元素重复加入容器。

ArrayList底层是用数组实现的存储。

特点：查询效率高，增删效率低，线程不安全。我们一般使用它。


import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class TestList {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		System.out.println(list.isEmpty());//容器是否为空
		list.add("老郑");
		System.out.println(list.isEmpty());
		list.add("老张");
		list.add("老王");
		System.out.println(list);
		System.out.println("list的大小："+list.size());
		System.out.println("list是否包含指定元素："+list.contains("老王a"));
		list.remove("老张");
		System.out.println(list);
		Object[] obj = list.toArray();
		System.out.println(obj);
		System.out.println("转换成Object数组："+Arrays.toString(obj));
		list.clear();//清空
		System.out.println("清空所有元素："+list);

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

public class TestList3 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("A");
		list.add("B");
		list.add("C");
		list.add("D");
		list.add("E");
		list.add("B");
		System.out.println(list);//[A, B, C, D, E]
		list.add(2,"shit");
		System.out.println(list);//[A, B, shit, C, D, E]在索引为2的地方增加
		
		list.remove(2);
		System.out.println(list);//[A, B, C, D, E]在索引为2的地方移除
		
		list.set(2, "bull");
		System.out.println(list);//[A, B, bull, D, E]在索引为2的地方设置值
		
		System.out.println(list.get(2));//返回bull
		
		list.add("Damn");
		System.out.println(list);//[A, B, bull, D, E, Damn]在后面加
		
		
		System.out.println(list.indexOf("B"));//从头到尾找到第一个“B”
		System.out.println(list.lastIndexOf("B"));//从末尾到开头找到第一个“B”
		
	}
}


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

/**测试两个容器之间元素处理
 * @author Administrator
 *
 */
public class TestList4 {
	public static void main(String[] args) {
		List<String> list1 = new ArrayList<String>();
		list1.add("小六");
		list1.add("小七");
		list1.add("小八");
		
		List<String> list2 = new ArrayList<String>();
		list2.add("小六");
		list2.add("张三");
		list2.add("李四");
		
		System.out.println(list1.contains(list2));//false  list1是否包含list2
		System.out.println(list1);
		
		list1.addAll(list2);//将list2中所有元素都添加到list1中
		System.out.println(list1);
		
//		list1.removeAll(list2);//从list1删除中同时在list1和list2中存在的元素
//		System.out.println(list1);
		
		System.out.println("list1"+list1);
		System.out.println("list2"+list2);
		list1.retainAll(list2);//取list1和list2的交集
		System.out.println(list1);
	}
}

LinkedList底层用双向链表实现的存储。

特点：查询效率低，增删效率高，线程不安全。

entry在英文中表示“进入、词条、条目”的意思。在计算机英语中一般表示“项、条目”的含义。

Map接口

Map就是用来存储“键(key)-值(value) 对”的。 Map类中存储的“键值对”通过键来标识，所以“键对象”不能重复。

Map 接口的实现类有HashMap、TreeMap、HashTable、Properties

import java.util.HashMap;
import java.util.Map;

/**测试Map常用方法
 * @author Administrator
 *
 */
public class TestMap {
	public static void main(String[] args) {
		Map<Integer, String> m1 = new HashMap<Integer, String>();
		Map<Integer, String> m2 = new HashMap<Integer, String>();
		m1.put(1, "one");
		m1.put(2, "two");
		m1.put(3, "three");
		m2.put(1, "一");
		m2.put(2, "二");
		System.out.println(m1.size());
		System.out.println(m1.containsKey(1));//判断是否包含指定key的键值对
		System.out.println(m1.containsValue("two"));//判断是否包含指定的Value的键值对
		m1.put(3, "third");//健重复了，则会替换旧的键值对
		System.out.println(m1);
		Map<Integer, String> m3 = new HashMap<Integer, String>();
		m3.putAll(m1);
		System.out.println(m3);
		m3.putAll(m2);
		System.out.println(m3);
		
		System.out.println("m1:"+m1);
		System.out.println("m2:"+m2);
		System.out.println("m3"+m3);
	}
}

HashMap和HashTable

HashMap与HashTable的区别

1. HashMap: 线程不安全，效率高。允许key或value为null。

2. HashTable: 线程安全，效率低。不允许key或value为null。

TreeMap

import java.util.Map;
import java.util.TreeMap;

public class TestTreeMap {
	public static void main(String[] args) {
		Map<Integer, String> treeMap1 = new TreeMap<Integer, String>();
		treeMap1.put(5, "张三");
		treeMap1.put(3, "李四");
		treeMap1.put(6, "王五");
		//按照key递增的方式排序
		for (Integer key : treeMap1.keySet()) {
			System.out.println(key+"---"+treeMap1.get(key));
		}
		
		Map<Emp, String> treeMap2 = new TreeMap<Emp, String>();
		treeMap2.put(new Emp(1001, "张三", 30000), "张三是好小伙");
		treeMap2.put(new Emp(1002, "李四", 5000), "精神小伙");
		treeMap2.put(new Emp(1000, "王五", 5000), "doub");
		//如果薪水相同，则按照id排序
		for (Emp key : treeMap2.keySet()) {
			System.out.println(key+"---"+treeMap2.get(key));
		}
	}
}
class Emp implements Comparable<Emp>{
	int id;
	String name;
	double salary;
	@Override
	public String toString() {
		return "Emp [id=" + id + ", name=" + name + ", salary=" + salary + "]";
	}
	public Emp(int id, String name, double salary) {
		super();
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	@Override
	public int compareTo(Emp o) {//负数：小于   。0：等于   。整数：大于
		if (this.salary > o.salary) {
			return 1;
		}else if (this.salary < o.salary) {
			return -1;
		}else {
			if (this.id > o.id) {
				return 1;
			}else if (this.id < o.id) {
				return -1;
			}else {
				return 0;
				
			}
		}
	}
	
	
}

set接口

Set常用的实现类有：HashSet、TreeSet等，我们一般使用HashSet。

HashSet：添加和输出的顺序不符，

LinkedHashSet：保证添加顺序，

TreeSet：按照自然顺序排序


import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class TestTreeSet {
	public static void main(String[] args) {
		User user1 = new User(1001, "张三", 18);
		User user2 = new User(2001, "李四", 20);
		
		Set<User> set = new TreeSet<User>();
		set.add(user1);
		set.add(user2);
		System.out.println(set);
		for (Iterator<User> iterator = set.iterator();iterator.hasNext();) {
			User user = iterator.next();
			System.out.println("迭代器"+user);
		}
		
	}
}
class User implements Comparable<User>{
	int id;
	String name;
	int age;
	
	
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	public User(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	//返回0表示this == obj 返回整数表示this>obj 返回负数表示this<obj
	@Override
	public int compareTo(User o) {
		if (this.id > o.id) {
			return 1;
		}else if (this.id <o.id) {
			return -1;
		}else {
			return 0;
			
		}
	}
	
}

Hashset


import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class TestTreeSet {
	public static void main(String[] args) {
		User user1 = new User(1001, "张三", 18);
		User user2 = new User(2001, "李四", 20);
		
		Set<User> set = new TreeSet<User>();
		set.add(user1);
		set.add(user2);
		System.out.println(set);
		for (Iterator<User> iterator = set.iterator();iterator.hasNext();) {
			User user = iterator.next();
			System.out.println("迭代器"+user);
		}
		
	}
}
class User implements Comparable<User>{
	int id;
	String name;
	int age;
	
	
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	public User(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	//返回0表示this == obj 返回整数表示this>obj 返回负数表示this<obj
	@Override
	public int compareTo(User o) {
		if (this.id > o.id) {
			return 1;
		}else if (this.id <o.id) {
			return -1;
		}else {
			return 0;
			
		}
	}
	
}

collections工具类

1. void sort(List) //对List容器内的元素排序，排序的规则是按照升序进行排序。

2. void shuffle(List) //对List容器内的元素进行随机排列。

3. void reverse(List) //对List容器内的元素进行逆续排列。

4. void fill(List, Object) //用一个特定的对象重写整个List容器。

5. int binarySearch(List, Object)//对于顺序的List容器，采用折半查找的方法查找特定对象

public class Test {
    public static void main(String[] args) {
        List<String> aList = new ArrayList<String>();
        for (int i = 0; i < 5; i++){
            aList.add("a" + i);
        }
        System.out.println(aList);
        Collections.shuffle(aList); // 随机排列
        System.out.println(aList);
        Collections.reverse(aList); // 逆续
        System.out.println(aList);
        Collections.sort(aList); // 排序
        System.out.println(aList);
        System.out.println(Collections.binarySearch(aList, "a2")); 
        Collections.fill(aList, "hello");
        System.out.println(aList);
    }
}

遍历集合的方法总结

遍历List方法一：普通for循环

for(int i=0;i<list.size();i++){

    String temp = (String)list.get(i);//list为集合的对象名

    System.out.println(temp);

}

遍历List方法二：增强for循环(使用泛型!)

for(String temp : list) {

    System.out.println(temp);

}

遍历List方法三：使用Iterator迭代器(1)

for(Iterator iter= list.iterator();iter.hasNext();){

    String temp = (String)iter.next();

    System.out.println(temp);

}

遍历List方法四：使用Iterator迭代器(2)

Iterator iter =list.iterator();

while(iter.hasNext()){

    Object obj = iter.next();

    iter.remove();//如果要遍历时，删除集合中的元素，建议使用这种方式！ 

    System.out.println(obj);

}

遍历Set方法一：增强for循环

for(String temp:set){

    System.out.println(temp);

}

遍历Set方法二：使用Iterator迭代器

for(Iterator iter = set.iterator();iter.hasNext();){

    String temp = (String)iter.next();

    System.out.println(temp);

}