java基础之集合

collection 接口定义
    collection接口的定义
public interface Collection<E> extends Iterable<E>
collection子接口的定义
    list 可以放重复内容
set 不能放重复内容，所有重复内容靠hashcode（）和equals（）俩个方法区分
queue：队列接口
Sortset：可以对结合中的数据进行排序
List接口
    public class TestLinklist {
    /*public static void main(String[] args) {
*//**
* LinkList 实现了list接口，实现了queue
* FIFO(先进先出)
*//*
    LinkedList<String> link= new LinkedList<>();
    link.add("a");
    link.add("b");
    link.add("c");
    System.out.println("初始化"+link);
    link.addFirst("X");
    link.addLast("C");
    System.out.println("增加首尾的list"+link);
    System.out.println("找到link的头"+link.element());
    System.out.println("peek的头"+link.peek());//找到但不删除表头
    System.out.println("找到poll的头"+link.poll());//找出表头并删除表头
    System.out.println("link"+link);
   
}*/
public static void main(String[] args) {
LinkedList<String> link= new LinkedList<>();
    link.add("a");
    link.add("b");
    link.add("c");
    System.out.println("初始化"+link);
    for (int i = 0; i < link.size()+2; i++) {
    System.out.println( link.poll());  //先进先出
}
    // System.out.println("循环移除后的link"+link);
}
}   
    public class TestList {
public static void main(String[] args) {
List<String> list = new Vector<>();
list.add("aa");
list.add("bb");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
//线程安全
Vector<String> a =new Vector<>();
a.addElement("vv");
a.addElement("dd");
for (int i = 0; i < a.size(); i++) {
System.out.println(a.get(i));
}
}
}
set接口
    散列的存放：HashSet
public class TestHashSet {
    public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("a");
set.add("b");
set.add("c");
set.add("a");
set.add("b");
set.add("c");
System.out.println("重复内容不能添加"+set);
}
}
    treeset
//自定义treeSet
class Person implements Comparable<Person>{
private String name;
private int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
//必须重写equals 与hashcode方法 
return this.name.hashCode()*this.age;
}
@Override
public boolean equals(Object obj) {
if (this == obj)//地址相等
return true;
if(!(obj instanceof Person))
return false;
Person p =(Person) obj;
if(this.name.equals(p.name) && this.age==p.age)
return true;
return false;
}
@Override
public int compareTo(Person o) {
if(this.age>o.age)
return 1;
if(this.age<o.age){
return -1;
}else{
return this.name.compareTo(o.name);
}
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}

}
public class TreeSetTest {
    public static void main(String[] args) {
/*TreeSet<String> set =new TreeSet<>();//有序存放
set.add("c");
set.add("x");
set.add("a");
System.out.println("排序之后的treeset"+set);*/
   
    //自定义treeset
    TreeSet<Person> set =new TreeSet<>();
    set.add(new Person("zhangsan", 18));
    set.add(new Person("zhangsan", 18));
    System.out.println(set.toString());
}
}

    sortset
public class TestSortset {
//treeset 实现了 Sortset
    public static void main(String[] args) {
SortedSet<String> set =new TreeSet<>();
set.add("a");
set.add("d");
set.add("b");
set.add("c");
set.add("a");
set.add("d");
set.add("b");
set.add("c");
System.out.println("第一个元素"+set.first());
System.out.println("最后一个元素"+set.last());
System.out.println("headset"+set.headSet("c"));
System.out.println("subset"+set.subSet("a", "c"));
}
}
集合的输出
    Iterator:迭代输出
listIterator：专门用于输出list
Enumeration 是一个就的接口，功能与iterator类似
foreach：jdk1.5之后新功能
public class TestIterator {
    public static void main(String[] args) {
List<String> list=new ArrayList<>();
list.add("a");
list.add("b");
list.add("v");
list.add("d");
/* Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}*/
ListIterator<String> listIterator = list.listIterator();
 
while (listIterator.hasNext()) {
System.out.println(listIterator.next());
}
System.out.println("========================");
while (listIterator.hasPrevious()) {
System.out.println(listIterator.previous());
}
}
}
map接口
    hashMap：无序存放，是新的操作类，key不允许重复
/**
* hashtable 是线程安全的，性能较低 hashmap与此相反
* @param args
*/
public static void main(String[] args) {
// 实际上key value 保存在map.entry的实例，之后再map集合中添加map.entry
Map<String, String> map = new HashMap<>();
map.put("a", "1");
map.put("b", "1");
map.put("c", "1");
map.put("d", "1");
System.out.println(map.get("a"));
if(map.containsKey("a")){
System.out.println("a键存在！");
}
//输出全部键
Set<String> keySet = map.keySet();
System.out.println(keySet);
//输出全部值
Collection<String> values = map.values();
System.out.println(values);
}
}
hashtable：无序存放，是旧的操作类，key不允许重复
treemap：可以排序的map，按集合中的key排序，key不允许重复
public class TestTreeMap {
public static void main(String[] args) {
TreeMap<String, Integer> tree = new TreeMap<>();
tree.put("a", 1);
tree.put("f", 2);
tree.put("w", 3);
tree.put("b", 5);
tree.put("d", 7);
System.out.println(tree);
}
}


weakHashmap：弱引用的map集合。
public class TestWeakHashMap {
public static void main(String[] args) {
WeakHashMap<String, String> weak = new WeakHashMap<>();
weak.put(new String("a"), new String("22"));
weak.put(new String("b"), new String("221"));
weak.put(new String("c"), new String("222"));
System.gc();
weak.put(new String("ddddd"), new String("22"));//一般情况下只会剩下ddddd
System.out.println(weak);
}
}
集合工具类
    public class TestCollections {
public static void main(String[] args) {
//为集合添加新的内容
List<String> list =new ArrayList<>();
Collections.addAll(list, "v","c","d");
//正常输出每个元素应该使用迭代器或者for循环
System.out.println(list);
//翻转集合中的内容
Collections.reverse(list);
System.out.println(list);
//搜搜内容
int binarySearch = Collections.binarySearch(list, "c");
System.out.println(binarySearch);
Collections.replaceAll(list, "v", "workhard");
System.out.println(list);
//排序
Collections.sort(list);
System.out.println(list);
}
}
其他集合类
    public class TestStack {
public static void main(String[] args) {
Stack<String> s =new Stack<>();
s.push("a");
s.push("c");
s.push("d");
s.pop();
System.out.println(s);
s.pop();
System.out.println(s);
s.pop();
System.out.println(s);
s.pop();
}
}
属性类properties
    public class TestProperties {
public static void main(String[] args) throws FileNotFoundException, IOException {
Properties p =new Properties();
/*p.setProperty("beijong", "bj");
p.setProperty("shanghai", "sh");
p.setProperty("guangzhou", "gz");
File f = new File("d:"+File.separator+"pro.properties");
p.store(new FileOutputStream(f), "info");*/
File f = new File("d:"+File.separator+"pro.properties");
p.load(new FileInputStream(f));
System.out.println(p.get("beijong"));
}
}
    //多对多关联关系 一个人可以学多个课程，一个课程也可以有多个学生
class Person1 {
private String name;
private int age;
private List<Course> list;

public Person1(String name, int age) {
this();
this.name = name;
this.age = age;
}
public Person1() {
list=new ArrayList<>();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public List<Course> getList() {
return list;
}
public void setList(List<Course> list) {
this.list = list;
}
@Override
public String toString() {
return "Person1 [name=" + name + ", age=" + age ;
}

}
class Course{
    private String name;
    private int i;
    private List<Person1> p;
public Course() {
p =new ArrayList<>();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
public List<Person1> getP() {
return p;
}
public void setP(List<Person1> p) {
this.p = p;
}
@Override
public String toString() {
return "Course [name=" + name + ", i=" + i + ", p=" + p + "]";
}
public Course(String name, int i) {
this();
this.name = name;
this.i = i;
}

}
public class TestManytoMany {
     public static void main(String[] args) {
Course c = new Course("计算机", 1);
Course c1 = new Course("java", 2);
Person1  s1=new Person1("ll",18);
Person1 s2=new Person1("llhaha",18);
c.getP().add(s1);
c1.getP().add(s2);
s2.getList().add(c1);
s1.getList().add(c);
Iterator<Person1> iterator = c.getP().iterator();

while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}