集合基础（三），线程

最新推荐文章于 2024-06-20 20:20:21 发布
最新推荐文章于 2024-06-20 20:20:21 发布
阅读量114 收藏
点赞数
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45575912/article/details/115703324
版权

1.TreeMap

TreeSet的底层就是由TreeMap维护的，底层原理：红黑树。

特点：有序（默认升序排序），存放存储与内部真实存储顺序是不一致的；

注意：有什么功能|结构能够实现排序的，想到比较器，指定比较规则；

去重排序：根据key实现，key中存放数据的类型——>

​ 1）实现内部比较器

​ 2）实现外部比较器

public class PracticeDemo {
    public static void main(String[] args) throws IOException {
        //创建TreeMap对象
        TreeMap<User,String> map = new TreeMap<>();
        //增加元素
        map.put(new User("aaa",15),"新浪");
        map.put(new User("bbb",16),"新浪");
        map.put(new User("ccc",17),"新浪");
        map.put(new User("aaa",16),"新浪");
        map.put(new User("abc",15),"新浪");
        System.out.println(map);
        System.out.println("===================");
        //使用entrySet进行遍历
        Set<Map.Entry<User,String>> set = map.entrySet();
        Iterator<Map.Entry<User,String>> it = set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //values遍历，打印values的值
        Collection<String> col = map.values();
        Iterator<String> it3 = col.iterator();
        while(it3.hasNext()){
            System.out.println(it3.next());
        }
       
}
class User implements Comparable<User>{
    private String name;
    private int age;

    public User() {
    }
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age &&
                Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(User o) {
        return this.getName().compareTo(o.getName());
    }
}

2.Properties

属于Map接口下的实现类。

存储的键值对都为字符串类型；

Properties类表示一组持久的属性；

Properties格式作为配置文件得格式存在，键值对都是字符串；

配置文件：

  • 文件中指定一些程序执行过程中需要的一些数据|参数|路径；
  • 帮助我们实现软编码风格（经常修改的数据与源代码分离开，避免经常修改操作源代码——>硬编码）；
//properties中的内容
账户:账户1
密码:密码1
age:15

程序从properties文件中读取数据：

 //properties作为配置文件
        Properties pro = new Properties();
        pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("xx.properties"));
        System.out.println(pro.getProperty("账户"));
        System.out.println(pro.getProperty("密码"));
        System.out.println(pro.getProperty("age"));
    }

总结：properties作为配置文件使用的步骤：

  • src下新建一个file文件,名字问xx.properties
  • zai配置文件中定义键值对为字符串的数据(注意不加"",;…)
  • 程序中定义个Properties对象.通过对象.load(流) 指定从某一个资源文件中读取数据,使用指定的流
  • 对象.getProperty(key)

3.Collections

CollectionsCollection的区别：

  • Collection是集合体系的上层接口；
  • Collections操作集合数据的工具，与Arrays很像；

常用方法：

  • void sort 排序；
  • void reverse 倒转；
  • void binarySrearch 将排序好的集合进行二分查找；
  • void shuffle 随机排序；
public class CollectionsDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(4);
        list.add(2);
        list.add(5);
        list.add(3);
        list.add(1);
        System.out.println(list);
        //升序排序
        Collections.sort(list);
        System.out.println(list);
        //倒转
        Collections.reverse(list);
        System.out.println(list);
        //乱序
        Collections.shuffle(list);
        System.out.println(list);
        //查找,前提是必须将集合排序
        Collections.sort(list);
        System.out.println(Collections.binarySearch(list,2));
    }
}

4.线程安全问题

  • Hashtable类型,线程安全的HashMap；Hashtable是同步的。 如果不需要线程安全实现，建议使用HashMap代替Hashtable 。 如果需要线程安全的高度并发实现，则建议使用ConcurrentHashMap代替Hashtable ；
  • Collections -> static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 返回由指定映射支持的同步（线程安全）映射；
  • juc包(高级并发编程包) - > ConcurrentHashMap 线程安全的哈希表—>推荐,安全性好效率高；

5.线程

单线程：单个任务，一个执行路径，一个顺序流；

多线程：多个任务执行，多个路径执行，多个顺序流，优点是效率高；

​ 串行：在同一个时间段内，多个任务快速串行执行

​ 并行：在同一个时刻内，多任务同时执行；

5.1创建线程和开启线程

  • 继承Thread，重写run()+start()：
public class ThreadDemo extends Thread{
    public static void main(String[] args) throws InterruptedException {
        //创建本类的对象
        ThreadDemo th =new ThreadDemo();
        //通过本类对象调用重写的方法
        th.start();
        for(int i = 0;i<=20;i++){
            System.out.println("歇一歇");
            Thread.sleep(100);
        }
    }
    //重写run方法
    @Override
    public void run() {
        for(int i = 0;i<=20;i++){
            System.out.println("做俯卧撑");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
  • 实现Runnable，重写run()方法，方法内部定义线程体+start()；接口可以多实现，而类只能单继承，此方法也可以资源共享；
//实现Runnable接口
public class ThreadDemo02 implements Runnable{
    public static void main(String[] args) throws InterruptedException {
        //创建Thread对象，它的实参为本类的对象（重写run方法的对象）
        new Thread(new ThreadDemo02()).start();
        for(int i =0;i<=50;i++){
            System.out.println("下去");
            Thread.sleep(100);
        }
    }
    //重写run方法
    @Override
    public void run() {
        for(int i =0;i<=50;i++){
            System.out.println("上去了");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

使用内部类实现此方法：

public class ThreadDemo03 {
    //内部类
    class Inner1 implements Runnable{
        @Override
        public void run() {
            for(int i = 0;i<51;i++){
                System.out.println(Thread.currentThread().getName()+"吃饭！！！");
            }
        }
    }

    public static void main(String[] args) {
        ThreadDemo03 th = new ThreadDemo03();
        //调用非静态内部类，需要使用类对象调用
        new Thread(th.new Inner1(),"a").start();
        new Thread(th.new Inner1(),"b").start();
        //lambda表达式
        new Thread(()->{
            for(int i = 0;i<51;i++){
                System.out.println(Thread.currentThread().getName()+"睡觉！！！");
            }
        },"c").start();
    }
}

12306练习：

public class Web12306 implements Runnable{
    int tickets = 100;
    public static void main(String[] args) {
        Web12306 web = new Web12306();
        new Thread(web,"小张").start();
        new Thread(web,"小王").start();
        new Thread(web,"小李").start();
    }

    @Override
    public void run() {
        while(tickets>0){
            System.out.println(Thread.currentThread().getName()+"抢到了第"+tickets--+"票");
            try{
                Thread.sleep(100);
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

归途赛跑例子：

public class Race{
    public static void main(String[] args) {
        Match match = new Match();
        new Thread(match,"乌龟").start();
        new Thread(match,"兔子").start();
    }
}
//定义一个比赛类
class Match implements Runnable{
    //此成员变量作为比赛停止条件
    private String name;
    @Override
    //重写的run方法
    public void run() {
        for(int i = 1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+"跑了："+i+"步");
            //此if判断调用该线程的是否为兔子，如果是，则每20步停下20毫秒
            if("兔子".equals(Thread.currentThread().getName()) && i%20==0){
                try{
                    Thread.sleep(2);
                }
                catch (Exception e){
                    e.printStackTrace();
                }
            }
            if(checkOut(i)){
                break;
            }
        }
    }
    //判断是否结束进程的方法
    public boolean checkOut(int i){
        if(name !=null){
            return true;
        }
        if(i == 100){
            name = Thread.currentThread().getName();
            return true;
        }
        return false;
    }
}
  • Callable接口 call() 定义线程体，优点是可以抛出异常，可以定义返回值；
public class ThreadDemo05 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Match2 match = new Match2();

        //通过线程池 固定大小线程池2个  static ExecutorService newFixedThreadPool​(int nThreads)
        //1.创建执行服务
        ExecutorService server = Executors.newFixedThreadPool(2);
        //2.提交任务  <T> Future<T> submit(Callable<T> task) 提交值返回任务以执行并返回表示任务的挂起结果的Future。
        Future<Integer> f1 = server.submit(match);
        Future<Integer> f2 = server.submit(match);

        //3.获取结果
        Integer result1 = f1.get();
        Integer result2 = f2.get();

        System.out.println(result1);
        System.out.println(result2);

        //4.结束服务
        server.shutdown();

    }
}

//比赛
class Match2 implements Callable<Integer> {
    //结束标识
    private String winner;  //记录赢的人的名字


    /*
        可以抛出异常
     */
    @Override
    public Integer call() throws InterruptedException {
        //i作为步数
        for(int i=1;i<=100;i++){
            //是否为兔子
            System.out.println(Thread.currentThread().getName()+"正在跑第"+i+"步");
            if("兔子".equals(Thread.currentThread().getName()) && i%20==0){
               Thread.sleep(20);
            }
            //结束判断
            if(checkOver(i)){
                return i;
            }
        }
        return null;
    }

    //结束的条件判定  返回值: true结束   false不结束
    public boolean  checkOver(int steps){
        boolean flag = false;
        //有人赢了
        if(winner != null){
            return true;
        }
        //自己赢了
        if(steps==100){
            winner = Thread.currentThread().getName();
            return true;
        }
        return false;
    }
鸽了一路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
集合&线程
qq_43711904的博客
11-26 164
目录 1 回顾：类集 2 线程 3 练习：实现链表 4 练习：多线程-打印操作 1 回顾 类集：https://blog.csdn.net/qq_43711904/article/details/97113574 集合输出：https://blog.csdn.net/qq_43711904/article/details/97489552 2 线程 https://blog...
集合与线程
blank_zio的博客
06-07 130
List接口的特点: 1.有序的集合,存储元素和取出元素的顺序是一致的(存储123 取出123) 2.有索引,包含了一些带索引的方法 3.允许存储重复的元素 List<String> list = new ArrayList<>(); //使用add方法往集合中添加元素 list.add("a"); //public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
Java大总结（三）—— 集合框架、流、多线程
Alisa_ljn的博客
03-10 432
五、集合框架 1. javabean特性、作用 (1)所有的类必须放在一个包中，在WEB中没有包的是不存在的 (2)所有的类必须声明为public class，这样才能够被外部所访问； (3)类中所有的属性都必须封装，即：使用private声明； (4)封装的属性如果需要被外部所操作，则必须编写对应的setter、getter方法； (5)一个JavaBean中至少存在一个无参构造方法，此为JSP...
JAVA面试题总结||——集合与线程
weixin_45441572的博客
12-11 483
1.1接口继承关系和实现: 集合存放于Java.util包中，主要有3种: set无序集合、list有序列表集合、map键值对映射。 1.Collection: Collection是集合List、Set、Queue的最基本的接口。 2.Iterator：迭代器，可以通过迭代器遍历集合中的数据。 3.Map：是映射表里的基础接口。
集合的线程安全解读
一个菜鸡的博客
04-10 350
首先我们对 CopyOnWriteArrayList 进行学习,其特点如下: 它相当于线程安全的 ArrayList。和 ArrayList 一样，它是个可变数组；
java线程基础
12-21
进程：进程是执行中的程序，是多个线程的集合，一个操作系统可以有多个进程，每个进程可以有多条执行路径。在进程中一定有一个主线程可以控制代码执行顺序 线程 在进程中，线程就是一个执行流程，正在独立运行的一条...
Java集合框架的线程安全.docx
05-10
Java 集合框架包括三个部分：接口、实现和算法。接口是抽象数据类型的表示集合，接口使得集合的操作和集合的具体实现细节相独立。在面对对象的语言里，这些接口一般形成一个层次结构。实现是指表示这些集合接口的...
python 线程的使用 python线程基础知识，提供python2示例代码，供参考学习
08-18
python 线程的使用 python线程基础知识，提供python2示例代码，供参考学习 python 提供thread和theading两个线程模块，thread较底层，threading较方便，大多数情况下使用theading就足够了； thread_test.py start(),...
Java基础下资料集合IO流多线程
11-14
Java基础下资料集合IO流多线程
java多线程基础知识
01-25
三、线程之间的数据交换和通信 不同进程之间是不共享内存的。进程之间的数据交换和通信成本很高——淘宝要调用支付宝付款，微信调用相机。线程是CPU执行和调度的最小单位。 四、线程的创建和启动 有两种方法可以...
线程（集合的线程安全问题）
normol的博客
03-29 2114
集合与线程安全 iterator CAS算法 集合与线程安全 Do you notice that all the basic collection classes - ArrayList, LinkedList, HashMap, HashSet, TreeMap, TreeSet, etc - all are not synchronized? In fact, all...
Java哪些集合类是线程安全的？
laowang2915的博客
06-23 1万+
Java哪些集合类是线程安全的？        早在jdk的1.1版本中，所有的集合都是线程安全的。但是在1.2以及之后的版本中就出现了一些线程不安全的集合，为什么版本升级会出现一些线程不安全的集合呢？因为线程不安全的集合普遍比线程安全的集合效率高的多。随着业务的发展，特别是在web应用中，为了提高用户体验减少用户的等待时间，页面响应速度(也就是效率)是优先考虑的。而且对线程不安全的集合加锁以后
基础知识总结：线程安全的集合与线程不安全的集合
weixin_40773253的博客
11-14 8915
集合大概有4种类型：List   Set   Queue  Map 其中Vector、HashTable、Properties是线程安全的。其中ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等都是线程不安全的。（线程不安全是指：当多个线程访问同一个集合或Map时，如果有超过一个线程修改了ArrayList集合，则程序必须手动保证该集合的同
java中哪些集合是线程安全的，哪些是线程不安全的
热门推荐
城序猿
05-09 2万+
目录1. 常见集合2.什么叫“集合是线程不安全的”3. 线程安全和线程不安全的集合3. 如何综合考虑线程不安全和效率低的问题 1. 常见集合 这里自己总结了一些比较常见的java集合，对于这些集合的特点和区别后期博客中会进行总结介绍： 2.什么叫“集合是线程不安全的” 当多个并发同时对非线程安全的集合进行增删改的时候会破坏这些集合的数据完整性； 例如：当多个线程访问同一个集合或Map时，如果有超...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 488
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
最新发布
m0_67496588的博客
06-20 511
JSON，Ajax
基于springboot的青年公寓服务平台源码数据库
s123456sj的博客
06-16 1192
本青年公寓服务平台分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理房屋投诉信息以及房屋投诉的租赁信息，能够与用户进行相互交流等操作，用户可以查看房屋信息，可以查看房屋投诉以及查看管理员回复信息等操作。
Java 中 什么是 lambda 表达式？有什么优点？
liangzai215的专栏
06-13 909
但是，Lambda 表达式绝对不是 Java 8 的银弹，它在消除代码冗余、支持并发这两方面表现优秀，但是在其他方面并未有太多贡献，所以我们在编程的时候，还是需要结合实际情况，灵活选择使用。Lambda表达式在Java 8中是非常强大的工具，但是需要注意的是，Lambda并并不适合所有情况，它主要适用于函数式编程，处理集合操作和Stream操作，在某些具体的业务逻辑操作中就不一定会产生预期的效果。代码块：是 Lambda 表达式需要执行的功能，可以是一行代码，也可以是复杂的多行代码。
学习java的多线程与高并发需要有什么基础
06-10
学习Java的多线程与高并发需要掌握Java基础语法、面向对象编程、集合框架、IO流等基础知识。同时也需要了解操作系统的基本原理、计算机网络、数据库等相关知识，以便更好地理解Java多线程和高并发的实现原理。此外，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值