带你入门Java的集合

package com.aggregate.demo;

import com.sun.corba.se.spi.ior.IORTemplateList;

import java.util.HashSet;

import java.util.Iterator;

public class set {

     public static void main(String[] args) {

         HashSet<Object> set = new HashSet<>();

         set.add( 1 );

         set.add( "a" ); //增加元素

         System.out.println(set);

         set.remove( 1 ); //移除元素

         System.out.println(set);

         System.out.println(set.contains( "a" )); //判断集合中是否存在该元素

         set.clear(); //清空集合

         System.out.println(set);

         //遍历集合

         set.add( "a" );

         set.add( "b" );

         set.add( "c" );

         set.add( "d" );

         //1.使用迭代器遍历集合

         Iterator<Object> iterator = set.iterator();

         while (iterator.hasNext()) {

             System.out.print(iterator.next() + "\t" );

         }

         System.out.println( "===============" );

         //2.for each迭代集合

         for (Object i : set) {

             System.out.print(i + "\t" );

         }

         System.out.println( "===============" );

         System.out.println(set.size()); //获取元素的个数

         set.add( null );

         System.out.println(set);

         //使用泛型存相同类型的元素

         HashSet<String> set1 = new HashSet<>();

         set1.add( "123" );

//      set1.add(2);

     }

}

import java.util.Comparator;

import java.util.Iterator;

import java.util.TreeSet;

public class Tree {

     public static void main(String[] args) {

         TreeSet<Integer> treeSet = new TreeSet<>();

         //TreeSet自然排序

         treeSet.add( 5 );

         treeSet.add( 1 );

         treeSet.add( 3 );

         treeSet.add( 2 );

         treeSet.add( 4 );

         System.out.println(treeSet);

         treeSet.remove( 3 );

         System.out.println(treeSet);

         System.out.println(treeSet.contains( 0 ));

         treeSet.clear();

         System.out.println(treeSet);

         Iterator<Integer> iterator = treeSet.iterator();

         while (iterator.hasNext()) {

             System.out.println(iterator.next());

         }

         System.out.println( "=============" );

         for (Integer i : treeSet) {

             System.out.println(i);

         }

         Person P1 = new Person( 23 , "张三" );

         Person P2 = new Person( 25 , "李四" );

         Person P3 = new Person( 12 , "王五" );

         Person P4 = new Person( 5 , "Lucy" );

         Person P5 = new Person( 99 , "hhhh" );

         TreeSet<Person> people = new TreeSet<>( new Person());

         people.add(P1);

         people.add(P2);

         people.add(P3);

         people.add(P4);

         people.add(P5);

         for (Person i : people) {

             System.out.println(i.name + "  " + i.age);

         }

     }

}

//把person对象存到TreeSet中并且按照年龄排序

class Person implements Comparator<Person> {

     int age;

     String name;

     public Person() {

     }

     public Person( int age, String name) {

         this .age = age;

         this .name = name;

     }

     @Override

     public int compare(Person o1, Person o2) { //年龄正序排序

         if (o1.age > o2.age) {

             return 1 ;

         } else if (o1.age < o2.age) {

             return - 1 ;

         } else {

             return 0 ;

         }

     }

}

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

public class MapDemo {

     public static void main(String[] args) {

         Map<String, Integer> map = new HashMap<String, Integer>();

         map.put( "b" , 1 ); //添加数据

         map.put( "c" , 2 );

         map.put( "d" , 3 );

         System.out.println(map);

         System.out.println(map.get( "d" )); //根据key取值

         map.remove( "c" );

         System.out.println(map); //根据key键值对

         System.out.println(map.size()); //map集合的长度

         System.out.println(map.containsKey( "a" )); //判断当前的map集合是否包含指定的key

         System.out.println(map.containsValue( 10 )); //判断当前的map集合是否包含指定的value

//        map.clear();//清空集合

         Set<String> keys = map.keySet(); //可以获取map集合的key的集合

         map.values(); //获取集合的所有value值

         //遍历map集合,通过map.keySet();

         for (String key : keys) {

             System.out.println( "key:" + key + ", value:" + map.get(key));

         }

         //通过map.entrySet();遍历集合

         Set<Map.Entry<String, Integer>> entries = map.entrySet();

         for (Map.Entry<String, Integer> entry : entries) {

             System.out.println( "key:" + entry.getKey() + ", value:" + entry.getValue());

         }

     }

}

import java.util.Map;

import java.util.TreeMap;

public class TreeMapDemo {

     public static void main(String[] args) {

         //TreeMap的自然排序是字典

         Map<Integer, String> treemap = new TreeMap<Integer, String>();

         treemap.put( 4 , "a" );

         treemap.put( 3 , "b" );

         treemap.put( 2 , "c" );

         treemap.put( 1 , "d" );

         System.out.println(treemap);

         Map<String, String> map = new TreeMap<String, String>();

         map.put( "a" , "a" );

         map.put( "c" , "a" );

         map.put( "d" , "a" );

         map.put( "b" , "a" );

         map.put( "ab" , "a" );

         System.out.println(map);

     }

}

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

public class Test {

     public static void main(String[] args) {

         List<String> list = new ArrayList<>();

         list.add( "a" );

         list.add( "c" );

         list.add( "d" );

         list.add( "f" );

         list.add( "b" );

         System.out.println(list);

         Collections.reverse(list); //反转List中元素的顺序

         System.out.println(list);

         Collections.shuffle(list); //对list集合元素进行顺序排序

         System.out.println(list);

         Collections.sort(list); //list集合字典升序排序

         System.out.println(list);

         Student s1 = new Student( 14 , "张三" );

         Student s2 = new Student( 12 , "李四" );

         Student s3 = new Student( 13 , "王五" );

         Student s4 = new Student( 11 , "小刘" );

         List<Student> students = new ArrayList<Student>();

         students.add(s1);

         students.add(s2);

         students.add(s3);

         students.add(s4);

         for (Student student : students) {

             System.out.println(student.name + "," + student.age);

         }

         Collections.sort(students, new Student());

         System.out.println( "==========" );

         for (Student student : students) {

             System.out.println(student.name + "," + student.age);

         }

         Collections.swap(list, 1 , 3 ); //将指定list集合中的i处元素和j处元素进行交换

         System.out.println(list);

         System.out.println(Collections.max(list));

         System.out.println(Collections.min(list));

         Student max = Collections.max(students, new Student());

         Student min = Collections.min(students, new Student());

         System.out.println(max.name + ", " + max.age);

         System.out.println(min.name + ", " + min.age);

         System.out.println(Collections.frequency(list, "a" ));

         System.out.println(Collections.replaceAll(list, "a" , "aa" ));

         System.out.println(list);

     }

}

class Student implements Comparator<Student> {

     int age;

     String name;

     public Student() {

     }

     public Student( int age, String name) {

         this .age = age;

         this .name = name;

     }

     @Override

     //根据年龄升序排序对象

     public int compare(Student o1, Student o2) {

         if (o1.age > o2.age) {

             return 1 ;

         } else if (o1.age < o2.age) {

             return - 1 ;

         } else {

             return 0 ;

         }

     }

}

public class Test2 {

     public static void main(String[] args) {

         A<String> a = new A<String>();

         a.setKey( "rexx" );

         String s = a.getKey();

         System.out.println(s);

     }

}

class A<T> {

     private T key;

     public T getKey() {

         return key;

     }

     public void setKey(T key) {

         this .key = key;

     }

}

package com.aggregate.demo;

public class Test3 {

     public static void main(String[] args) {

         B1<Object> b1 = new B1<Object>();

         B1<String> b2 = new B1<String>();

         B2 b3 = new B2();

         Cc cc = new Cc();

         cc.test( "xxx" );

         //泛型方法，在调用之前没有固定的数据类型

         //在调用时，传入的参数是什么类型，就会把泛型改成什么类型

         //也就是说，泛型方法会在调用时确定泛型具体的数据类型

         Integer integer = cc.test1( 2 );

         Boolean aBoolean = cc.test1( true );

     }

}

//定义泛型接口

interface IB<T> {

     T test(T t);

}

//未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中

class B1<T> implements IB<T> {

     @Override

     public T test(T t) {

         return null ;

     }

}

//传入实际参数

//如果实现接口时指定接口的泛型的具体数据类型

//这个类实现接口所有方法的位置都要泛型替换实际的具体数据类型

class B2 implements IB<String> {

     @Override

     public String test(String s) {

         return null ;

     }

}

//泛型方法

class Cc {

     public void test() {

     }

     //无返回值的泛型方法

     public <T> void test(T s) {

         T t = s;

     }

     public String test1(String s) {

         return s;

     }

     //有返回值的泛型方法

     public <T> T test1(T s) {

         return s;

     }

     public void test2(String... strs) {

         for (String s : strs) {

             System.out.println(s);

         }

     }

     //形参为可变参数的泛型方法

     public <T> void test2(T... strs) {

         for (T str : strs) {

             System.out.println(str);

         }

     }

}

//带泛型的类可以在类里面定义泛型的变量

class Dd<E> {

     private E e;

     //静态的泛型方法

     public static <T> void test3(T t) {

         //System.out.println(this.e);

         //在静态方法中，不能使用类定义泛型，如果要使用泛型，只能使用静态方法自己定义的泛型

         System.out.println(t);

     }

     //在类上定义的泛型，可以在普通的方法中使用

     public <T> void test(T s) {

         System.out.println( this .e);

         T t = s;

     }

}

public class Test5 {

     public static void main(String[] args) {

         //Season.SPRING,这段执行就是获取一个Season的对象

         Season spring = Season.SPRING;

         spring.showInfo();

         Season summer = Season.SUMMER;

         summer.showInfo();

         Season spring1 = Season.SPRING;

         //每次执行Season.SPRING获得是相同的对象，枚举类中的每个枚举都是单例模式的

         System.out.println(spring.equals(spring1));

         spring1.test();

     }

}

enum Season implements ITest {

     SPRING( "春" , "春暖花开" ), //此处相当于调用有参的私有构造

     SUMMER( "夏" , "夏日炎炎" ),

     AUTUMN( "秋" , "秋高气爽" ),

     WINTER( "冬" , "寒风凛冽" );

     private final String name;

     private final String desc;

     Season(String name, String desc) {

         this .name = name;

         this .desc = desc;

     }

     public void showInfo() {

         System.out.println( this .name + ":" + this .desc);

     }

     @Override

     public void test() {

         System.out.println( "这是实现的ITest接口的test方法" );

     }

}

interface ITest {

     void test();

}

import java.lang.annotation.*;

import java.util.ArrayList;

import java.util.List;

public class Test6 {

     public static void main(String[] args) {

         new TestB().test01();

         @SuppressWarnings ({})

         List list = new ArrayList();

     }

}

class TestA {

     public void test() {

     }

}

class TestB extends TestA {

     @TestAnn (id = 100 , desc = "姓名" )

     String name;

     @Override

     public void test() {

         super .test();

     }

     @Deprecated

     public void test01() {

     }

}

@Target (ElementType.FIELD) //这个注解类是给其他类的属性做注解

@Retention (RetentionPolicy.RUNTIME) //定义注解的声明周期

@Documented

@interface TestAnn {

     public int id() default 0 ;

     public String desc() default "" ;

}