JavaSE-05之集合类及数据结构

Collection集合

* 是单例集合的顶层接口，他表示一组对象，这些对象也称为collection的元素

* JDK不提供此接口的任何实现关系，它提供了更具体的子接口，如set和list实现

* 创建collection集合的对象：

* 多态的方式

* 具体的实现类Array List

*创建集合的对象：collection《string》 a=new arraylist<string>();

添加元素：a.add("hhhh");

集合的遍历：itertor 迭代器，集合的专用遍历方式

返回此集合中元素的迭代器，通过集合的iterator()方法得到，迭代器是一个接口

迭代器是通过集合的iterator()方法得到的

所以说他是依赖于集合而存在的

Collection<String> c=new ArrayList<String>();
        c.add("hello");
        c.add("hello");
        c.add("hello");

        Iterator<String>  it=c.iterator();
while(it.hasNext()){
    String s=it.next();
    System.out.println(s);

-----------------------

list集合：

概述：有序集合，精确控制里表中每个元素的插入位置。通过整数索引访问元素。

特点：存储和取出的元素一致，元素可以重复。

并发修改异常：

concurrentmodificationException

产生原因：迭代器遍历的过程中，通过对象修改了集合中的元素的长度，造成了迭代器

获取元素中判断预期修改值和实际修改值不一致

解决方案：用for循环遍历，然后用集合对象做对应的操作即可。

listiterator:列表迭代器

通过list集合的listiterator()方法得到，所以说他是list集合特有的迭代器

常用的方法：返回迭代的下一个元素，

* 返回元素中的上一个元素

增强for循环

简化数组和collection集合的遍历。

三种遍历方式：

import java.lang.reflect.Array;
import java.util.*;

public class COllextion1 {
    public static void main(String[] args) {
        List<st> s1 = new ArrayList<>();
        st s2 = new st("qq", 99);
        st s3 = new st("ww", 34);
        st s4 = new st("ee", 44);
        s1.add(s2);
        s1.add(s3);
        s1.add(s4);
        Iterator<st> it1 = s1.iterator();
        while (it1.hasNext()) {
            st q1 = it1.next();
            System.out.println(q1.getName() + q1.getAge());

        }
        System.out.println("=====");
        for (int a = 0; a < s1.size(); a++) {
            st q2 = s1.get(a);
            System.out.println(q2.getName() + q2.getAge());
        }
        System.out.println("=========");

        for (st q3 : s1) {
            System.out.println(q3.getName() + q3.getAge());
           
        }
    }
}

------------------------------

数据结构：

数据结构是计算机存储，组织数据的方式，是指相互之间纯在一种或者多种特定关系的数据元素的集合

通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率

常见的数据结构之：栈，是一种先进后出的模型

常见数据结构之队列：先进先出

常见数据结构之数组：查询数据通过索引定位，查询任意数据耗时相同，查询效率高，

删除数据时候，要将原始数据删除，同时后面每个数据前移，删除效率低，添加数据的时候，添加位置后的每个数据后移，添加效率极低

数组是一种查询快，增删慢的模型。

哈希值：

* 是JDK中根据对象的地址或者字符串或者数字算出来的int 类型的数值

*object中有一个方法是可以获取对象的哈希值

* public int hashCode();返回对象的哈希码值

* 对象的哈希码值特点：

* 同一个对象多次调用hashCode（）返回的哈希值是相同的

* 默认情况下，不同对象的哈希值是不同的，而重写hashCode()方法之后，可以实现让不同对象的哈希值相同

-------------------------------------

list集合子类特点

* 常用两个;ArrayList  LinkedList

* 1:底层数据结构是数组，查询快，增删慢

* 2：底层数据结构是链表，查询慢，增删快

 -------------------

set集合概述和特点：

* set<string>  set=new  Hashset<String>();

* 不包含重复的元素的集合

* 没有带索引的方法，所以不能用普通的for循环遍历

hashset集合概述和特点;

* 底层数据结构是哈希表

* 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素一致

* 没有带索引的方法，所以不能使用普通的for循环遍历

* 由于是set集合，所以是不包含重复元素的集合

hashset遍历对象

* 一定要重写来两个方法，

* hashcode()和equals();

* 自动生成即可

Linkedhashset集合的概述和特点：

* 哈希表和链表实现的set接口，具有可预测的迭代次序

* 有链表保证元素有序，也就是说元素的存储和取出孙旭是一致的

* 由哈希表保证元素唯一，也就是说没有重复的元素

LinkedHashSet<String> ll = new LinkedHashSet<>();
ll.add("hh");
ll.add("we");
ll.add("rr");
for (String s : ll) {
    System.out.println(s);
}

treeset集合的概述和特点：

* 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行的排序，具体的构造方法

TreeSet<Integer> ts = new TreeSet<>();
ts.add(10);
ts.add(60);
ts.add(40);
for (Integer a : ts) {
    System.out.println(a);

}

* 取决于构造方法

* treeset():根据其元素的自然排序进行排序

* treeset(comparator):根据指定的比较器进行排序

* 没有带索引的方法，所以不能使用普通的for循环遍历

*一定要重写父类里面的comparable方法，返回值不同，输出的序列也不同。

用Treeset集合存储自定义对象，带参构造方法

* 使用的是比较器排序对元素进行排序

* 比较器排序，就是让集合构造方法接受comparator的实现类对象，

public class Student01 implements Comparable<Student01>{
    private String name;
    private int age;

@Override
    public int compareTo(Student01 s) {
      //  return 0;
        //return 1;
        //按照年龄大小排序
        int num=this.age-s.age;
        //年龄相同的时候按照字母的顺序开头
       int num2= num==0?this.name.compareTo(s.name):num;
        return num2;
    }

* 重写compare(to1,to2);

* 重写方法的时候，一定要注意排序规则按照要求的主要条件和次要条件来写

package com.zhang.shen01;

import java.util.TreeSet;

public class TreeSetDemo01 {


    public static void main(String[] args) {
//创建集合对象
        TreeSet<Student01> ts=new TreeSet<Student01>();
        //创建学生对象
        Student01 s1=new Student01("qq",38);
        Student01 s2=new Student01("ww",28);
        Student01 s3=new Student01("ee",18);
        Student01 s4=new Student01("aa",18);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);

        for(Student01 s:ts){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

不重复的随机数：

Set<Integer> ss = new TreeSet<>();
Random r = new Random();
while (ss.size() < 10) {
    int num = r.nextInt(20) + 1;
    ss.add(num);
}
for (Integer a : ss) {
    System.out.println(a);
}

-----------------------------

Map集合：

map结合的使用和概述：

interface map《K,V》，K：键的类型，V：值的类型

将键映射到值的对象；不能包含重复的建，每个键可以映射到最多一个值

如果键相同，第二次输入会直接替换原先的数据。

 

  Map<String, String> map = new HashMap<String, String>();
        map.put("张沈", "zahgndhen ");
        map.put("呵呵", "长得很");
        map.put("合战", "客户");
        System.out.println(map.get("呵呵"));
        System.out.println("----------");
        System.out.println("获取所有键的集合");
        Set<String> set1 = map.keySet();
        for (String s : set1) {
            System.out.println(s);
        }
        System.out.println("--获取所有值的集合-");
        Collection<String> co = map.values();
        for (String s : co) {
            System.out.println(s);
        }
        System.out.println("--------");

 Set<Map.Entry<String, String>> en = map.entrySet();
        for (Map.Entry<String, String> ss : en) {
            String a = ss.getKey();
            String b = ss.getValue();
            System.out.println(a + b);
        }
案例：ArrayList集合存储hashmap元素并遍历：

Hasshmap集合存储Array List元素并且遍历：

 

案例统计字符出现的次数：

import java.util.*;

public class test2 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入已给富川");
        String line = s.nextLine();
        HashMap<Character, Integer> hh = new HashMap<>();
        for (int a = 0; a < line.length(); a++) {
            char key = line.charAt(a);
            Integer value = hh.get(key);
            if (value == null) {
                hh.put(key, 1);
            } else {
                value++;
                hh.put(key, value);
            }
        }
        StringBuilder sb = new StringBuilder();
        Set<Character> set = hh.keySet();
        for (Character key : set) {
            Integer a = hh.get(key);
            sb.append(key).append("(").append(a).append(")");
        }
        String s1 = sb.toString();
        System.out.println(s1);

    }
}

----------------------------------

Collections集合都是静态方法是针对集合操作的工具类

List<Integer> list = new ArrayList<>();
list.add(10);
list.add(90);
list.add(24);
list.add(45);
list.add(85);
//将集合按照圣墟排列
Collections.sort(list);
System.out.println(list);
//反转集合中的元素
Collections.reverse(list);
System.out.println(list);
//将集合进行随机排列
Collections.shuffle(list);
System.out.println(list);

案例学生对象并排序：

import java.util.*;

public class Collections1 {
    public static void main(String[] args) {
ArrayList<st> array=new ArrayList<>();
st s1=new st("aa",11);
st s2=new st("bb",11);
st s3=new st("cc",89);
st s4=new st("ac",89);
st s5=new st("cd",39);
array.add(s1);
array.add(s2);
array.add(s3);
array.add(s4);
array.add(s5);
Collections.sort(array, new Comparator<st>() {
    @Override
    public int compare(st s1, st s2) {
        //按照年龄大小排序，按照自，u顺序
        int num=s1.getAge()-s2.getAge();
        int num2=num==0?s1.getName().compareTo(s2.getName()):num;
        return num2;
    }
});
for(st s:array){
    System.out.println(s.getName()+s.getAge());
}

    }
}

案例：模拟斗地主

import javax.swing.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class zs26901 {
    public static void main(String[] args) {
        //c创建一个牌盒子,键是编号，值是牌
        HashMap<Integer, String> hm = new HashMap<>();
        //创建arraylist存初编号
        ArrayList<Integer> array = new ArrayList<>();
        String[] colors = {"♠", "♣", "♥", "♦"};
        String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
        //从0开始一次存入编号和值
        int index = 0;
        for (String number : numbers) {
            for (String color : colors) {
                hm.put(index, color + number);
                array.add(index);
                index++;
            }
        }
        hm.put(index, "大王");
        array.add(index);
        index++;
        hm.put(index, "小王");
        array.add(index);
        Collections.shuffle(array);
//发牌发的是编号
        TreeSet<Integer> one = new TreeSet<>();
        TreeSet<Integer> two = new TreeSet<>();
        TreeSet<Integer> three = new TreeSet<>();
        TreeSet<Integer> dp = new TreeSet<>();

        for (int a = 0; a < array.size(); a++) {
            int b = array.get(a);
            if (a >= array.size() - 3) {
                dp.add(b);
            } else if (a % 3 == 0) {
                one.add(b);
            } else if (a % 3 == 1) {
                two.add(b);
            } else if (a % 3 == 2) {
                three.add(b);
            }
        }
        lookpock("aa", one, hm);
        lookpock("bb", two, hm);
        lookpock("cc", three, hm);
        lookpock("dp", dp, hm);
    }

    //定义方法看牌
    public static void lookpock(String name, TreeSet<Integer> ts, HashMap<Integer, String> hm) {
        System.out.println(name + "的牌是");
        for (Integer key : ts) {
            String pock = hm.get(key);
            System.out.print(pock + " ");
        }
        System.out.println();
    }
}