java学习之集合

集合是一个容器，可以容纳其他类型数据，数组是一种简单的集合
集合中存储的是地址（引用），不能直接存基础数据。
集合本身就是一个对象

0x00集合基础思维导图，

在java中集合有两大类，一类是以单个方式，Collection为代表

二类是key对和value（键值对），Map为代表为代表

0x01Collection(interface)--基础方法

public static void main(String[] args) {
    Collection c=new ArrayList();
    c.add(1200);//自动装箱存进去的是一个对象的地址
    c.add(3.14);//向集合中增加元素
    c.add(true);
    System.out.println(c.contains(3.14));//返回一个boolen值确里面是否存在某值
    System.out.println(c.isEmpty());//判断集合是否为空
    System.out.println(c.size());;//类似于数组的length
    c.clear();//清空集合
    System.out.println(c.size());
    System.out.println("-------------");
    JAVA_collection.collection2();
    System.out.println("-------------");
    Object[] arryay1=c.toArray();//转化成数组
    for (int i = 0; i < arryay1.length; i++) {
        System.out.println(arryay1[i]);

    }

}

boolean add()	void clear()	toArray()	isempty()	boolean contains
添加数据	清空集合	转化成数组()	size是否为0	确定集合里面是否存在某个值

0x02迭代器 Iterator迭代器

1.Iterators是一个interface。Iterator 是Java集合框架的成员，但它与Collection系列、Map系列的集合不一样：Collection 系列集合、Map系列集合主要用于盛装其他对象，而Iterator则是主要用于遍历（即迭代访问）Collection 集合中的元素，Iterator对象也被称为迭代器。Iterator接口隐藏了各种Collection 实现类的底层细节，向应用程序提供遍历Collection集合元素的统一编程接口。
2.Iterator 必须依附于Collection对象，若有一个Iterator对象，则必然有一个与之关联的Collection对象。

  public static void collection2(){
    Collection c=new ArrayList();
    c.add("abc");
    c.add("efghe");
    c.add(100);
    c.add(new Object());
    //获得迭代器
    Iterator it =c.iterator();//集合结构发生改变就需要重新获取迭代器。
    while (it.hasNext()){//判断是否还有元素
        Object obj=it.next();
        System.out.println(obj);
    }
} public static void collection2(){
    Collection c=new ArrayList();
    c.add("abc");
    c.add("efghe");
    c.add(100);
    c.add(new Object());
    //获得迭代器
    Iterator it =c.iterator();
    while (it.hasNext()){
        Object obj=it.next();
        System.out.println(obj);
    }
    while (it.hasNext()){//使用迭代器去删除，不能直接使用集合直接去删除
        it.remove();
        System.out.println(c.size());
    }
}

}

Iterator方法图表

Object next	boolean hashNext()	void remove()
返回下一个元素	如果遍历的集合没有被遍历完返回True	移除一个元素

0x03List接口

1.List属于Collection的子接口。
2.List存储元素的特点，有序可重复，有序：有下标从0开始。

0x1AarryList集合

1.初始化容量是10;(底层先创建了一个长度0的数组，当添加第一个元素时，初始化容量为10)
2.集合底层是一个Object数组吗
3.扩容时时扩容1.5倍

0x2AarryList集合的特有常用方法

get	indexof	set	LastIndexof
访问索引值下标的对象	查找某元素第一次的下标	在某个位置代替该对象	查找某一对象最后一次出现的下标

0x3使用一下这些方法

public static void main(String[] args) {
    List myList=new ArrayList();
    myList.add("a");//默认向列表尾部插入元素
    myList.add("b");
    myList.add("c");
    myList.add(1,"king");//向列表指定位置插入元素会把后面的元素向后挪动。
    myList.set(2,"C");
    //不用迭代器遍历
    for (int i = 0; i < myList.size(); i++) {
        Object GET=myList.get(i);
        System.out.println(GET);

    }
    //获取指定对象第一次出现的索引下标
    System.out.println(myList.indexOf("king"));
    //指定对象最后出现一次的索引
    System.out.println(myList.lastIndexOf("c"));


}

0x4Linkedlist集合

1.它的底层是一个双向链表
2.对于链表来说检索效率较低，增删改除效率高。
3.存储的地址是不连续的

0x5Vector集合

1.底层是一个数组。
2.默认容量是10，扩容后容量是原来的2倍

0x04泛型机制

是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，而这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口。
注意:一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

0x1简单看一下泛型的在Iterator的简单应用

点击查看

public class Genericteset {
    public static void main(String[] args) {
        woman people_1=new woman();
        man people_2=new man();
        Collection list=new ArrayList<people>();//指定这个集合里面只能存储某类型的数据，这里指定的是people类的对象、
        list.add(people_1);
        list.add(people_2);
        Iterator<people> iterator =list.iterator();
        while (iterator.hasNext()){
            people obj=iterator.next();
            obj.move();


        }


    }
}
class people{
    public void move(){
        System.out.println("在移动");
    }

}
class woman extends people{
    @Override
    public void move() {
        System.out.println("女人在移动");
    }
}
class man extends people{
    @Override
    public void move() {
        System.out.println("男人在移动");
    }
}

0x2泛型的使用方法

 修饰符 interface 接口名<使用的泛型类型>
public interface MyInterface<r> {
  public abstract void add(r R);
  public abstract R getr();

}

 
 修饰符 class 类名<泛型类型>{}
 public interface JAVA_Test01<r>{
   prvite r R;      
 }

 修饰符 <泛型类型> 返回值 方法名(参数)
 public <r> void method(r R){
    System.out.println(R);

}
}
Iterator<泛型类型> 变量名=集合.iterator()
//使用迭代器去返回的值就不是仅仅是Object类了。

0x3自定义泛型

点击查看代码

class MyIterator<R>{
    public R get(){
        return  null;
    }
}
class MyTest_01{
    public static void main(String[] args) {
        MyIterator<String> it=new MyIterator<>();
        String s1=it.get();
    }
}

①定义格式：修饰符 <自定义泛型>返回值类型 函数名(自定义泛型 变量名){ } ②注意： a. 在方法上的自定义泛型的具体数据类型是调用该方法的时候传入实参的时候确定的。 b. 自定义泛型使用的标识符只要符合标识符的命名规则即可。 自定义泛型类 ###0x4增强for循环(foreach) 1.语法格式：for(数据类型 变量名：数组或者集合）{System.out.printlen(变量名)}

① 定义格式： class 类名<自定义泛型>{ }
② 如果静态的方法需要使用自定义泛型，那么需要在方法上自己声明使用。
③ 泛型类注意的事项：
a.在类上自定义的泛型的具体数据类型是在创建对象的时候指定的。
b.在类上自定义了泛型，如果创建该类的对象时没有指定泛型的具体类型，那么默认是Object类型。

代码

 public class JAVA_Foreach {
  public static void main(String[] args) {
      Collection list=new ArrayList();
      list.add(1);
      list.add(2);
      list.add("adc");
      for (Object obj:list){
          System.out.println(obj);
        }
    }
}

0X05Set接口

HashSet

1.无序不可重复
2.HashSet的值实际是存在HashMap的key值中

class HashSet_Test{
    public static void main(String[] args) {
        Set<String> myhashset=new HashSet<>();
        myhashset.add("hellow");
        myhashset.add("world");
        myhashset.add("这是1");
        myhashset.add("这是1");
        myhashset.add("这是2");
        for (Object obj:myhashset
             ) {
            System.out.println(obj);

        }
    }
}

这是输出结果，无序：进去是什么顺序出来不一定是哪个顺序。

TreeSet

1.无序不可重复，但是存储的的元素可以自动排序（根据大小排序）。
2.底层是一个TreeMap
3.TreeMap底层是一个二叉树
4.放到TreeMap集合的key部分
5.自定义的TreeSet无法自动排序，因为无法准备排序规则。

class TreeSet_Test{
    public static void main(String[] args) {
        Set myset=new TreeSet<>();
        myset.add(1);
        myset.add(3);
        myset.add(2);
        for (Object obj:myset
             ) {
            System.out.println(obj);

        }

    }
}//输出是1 2 3

0x06Map接口

1.键值对方式存储,key和value，key和value都是引用数据类型。
2.存储的都是存储对象地址

Map常用方法

public static void main(String[] args) {
     Map<Integer,String> mymap=new HashMap<>() ;
     mymap.put(1,"小钟");
     mymap.put(2,"小陈");
     mymap.put(3,"zl");
     mymap.put(4,"cwp");
     //通过key获得value值get方法
     String value1=mymap.get(2);
     System.out.println(value1);
     //获取键值对的数量
     int sum=mymap.size();
     System.out.println(sum);
     //通过remove删除键值对
     mymap.remove(3);
     System.out.println(mymap.size());
     //判断是否包含某个key和某个value--containskey---containsvalue
     System.out.println(mymap.containsKey(2));
     System.out.println(mymap.containsValue("zl"));//键值对3删了;
     //判断是否为空
     System.out.println(mymap.isEmpty());
     //获取所有的value
     Collection<String> myvalue=mymap.values();
     for (Object obj:myvalue
          ) {
         System.out.println(obj);

     }
     Set<Integer> mykey =mymap.keySet();
     System.out.println(mykey);



 }
}

size	containskey/containsvalue	get(key	put/remove	返回映射中包含的映射的Set
获取键值对的数量	是否包含某个key/value	通过key值获取value值	存放和删除数据	返回映射中包含的映射的Set

0x1遍历Map

    //p获取全部value值
    Collection<> 变量名=集合名.values
   Collection<String> values=map.values();

获取全部key值and遍历Map集合

 Set<Integer> keys=map.key.set();//获取全部key值
    Iterator<Integer> iterator=keys.iterator();
    while (iterator.hasNext()){
        Integer Key=iterator.next();
        map.get(Key);//通过get去获取
    }
  //通过entryset获取entrySet() 方法返回映射中包含的映射的 Set 视图。Set 视图意思是 HashMap 中所有的键值对都被看作是一个 set 集合。
  Set<Map.Entry<Integer,String>> set=mymap.entrySet();//把map转化成Set
    Iterator<Map.Entry<Integer,String>>  iterator1=set.iterator();
    while (iterator1.hasNext()){
        Map.Entry<Integer,String> obj= iterator1.next();
        Integer key=obj.getKey();
        String value= obj.getValue();
        System.out.println("key"+key+"and"+"value"+value);
       
    }

0x06Properties属性类

1.Properties是一个Map集合，继承Hashtable,它的key和value都是String类型
2.属性类对象
3.初始化容易16，扩容参数是2倍

class Properties_test{
    public static void main(String[] args) {
        Properties pro=new Properties();
        pro.setProperty("usename","root");
        pro.setProperty("password","root");
        String str1=pro.getProperty("usename");//还是通过key取值
        

    }
}

0x07Collections工具类

1.public static boolean addAll(Collection 数据, 数据... 数据) :往集合中添加一些元素。 2。public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
3.public static void sort(List list):将集合中元素按照默认规则排序。 4.public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。

    public static void main(String[] args) {

        ArrayList<Integer> list = new ArrayList<>();

        Collections.addAll(list, 123, 1243, 1354, 123);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
    }

0x08总结

1.本章重点掌握各种集合的存储特点
2.学会通过迭代器和加强for循环
3.各类集合的基础数据结构