Java笔记_13(集合进阶2)

这篇具有很好参考价值的文章主要介绍了Java笔记_13(集合进阶2)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、双列集合

双列集合体系结构
Java笔记_13(集合进阶2)

双列集合的特点

  1. 双列集合一次需要存一对数据,分别为键和值
  2. 键不能重复,值可以重复
  3. 键和值是一一对应的,每一个键只能找到自己对应的值
  4. 键+值这个整体我们称之为“键值对”或者“键值对对象”,在Java中叫做“Entry对象

1.1、Map的常见API

Map是双列集合的顶层接口,它的功能是全部双列集合都可以继承使用的

方法名称 说明
v put(K key,v value) 添加元素
v remove(object key) 根据键删除键值对元素
void clear() 移除所有的键值对元素
boolean containsKey(object key) 判断集合是否包含指定的键
boolean containsValue(object value) 判断集合是否包含指定的值
boolean isEmpty() 判断集合是否为空
int size() 集合的长度,也就是集合中键值对的个数
  • put方法细节
    • 在添加数据的时候,如果键不存在,那么直接把键值对对象添加到Map集合中,方法返回null
    • 在添加数据的时候,如果键是存在的,那么会把原有的键值对对象覆盖,会把被覆盖的值进行返回。
package Collection_two_Dome.MapDome;

import java.util.HashMap;
import java.util.Map;

public class Dome1 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();

        map.put("康师傅","kangshufu");
        map.put("可口","百事");
        map.put("段子","皮皮");
        map.put("可口","美年达");//会覆盖上面的可口

        map.put("段子","123");
        System.out.println(map);

        map.remove("康师傅");
        System.out.println(map);
        System.out.println(map.size());//集合长度
        //判断是否存在键
        boolean keyResult = map.containsKey("康师傅");
        System.out.println(keyResult);
        //判断是否存在值
        boolean ValueResult = map.containsValue("美年达");
        System.out.println(ValueResult);

        //清空
        map.clear();
        System.out.println(map.isEmpty());
        System.out.println(map);
    }
}

1.2、Map遍历方式一(键找值)

三种遍历方式

  • 迭代器遍历
  • 增强for遍历
  • forEach遍历
package Collection_two_Dome.MapDome;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;

public class Dome2 {
    public static void main(String[] args) {

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

        map.put("可乐",3);
        map.put("康师傅",1);
        map.put("汇源",5);
        map.put("沙市",4);

        Iterator it = map.keySet().iterator();
        while (it.hasNext()){
            Object next = it.next();
            int money = map.get(next);
            System.out.println(next +"="+money);
        }
        System.out.println("--------- ------------------------------");
        Set<String> strings = map.keySet();

        for (String string : strings) {
            int money = map.get(string);
            System.out.println(string+"="+money);
        }

        strings.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                Integer money = map.get(s);
                System.out.println(s+"="+money);
            }
        });
    }
}

1.3、Map集合遍历方法二(键值对)

  1. 利用entrySet方法返回一个Set集合
  2. 这个集合里面装的是键值对对象
  3. 在通过get方法分别得到keyvalue
package Collection_two_Dome.MapDome;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Dome3 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();

        map.put("可乐",3);
        map.put("康师傅",1);
        map.put("汇源",5);
        map.put("沙市",4);
        //通过entrySet()方法获得装键值对的set集合
        Set<Map.Entry<String, Integer>> entries = map.entrySet();

        for (Map.Entry<String, Integer> entry : entries) {
            //通过get方法依次得到键和值
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+"="+value);
        }
    }
}

1.4、Map集合遍历方法三(lambda表达式)

方法名称 说明
default void forEach(Biconsumer<? super K,? super V> action) 结合lambda遍历Map集合
package Collection_two_Dome.MapDome;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class Dome4 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();

        map.put("可乐",3);
        map.put("康师傅",1);
        map.put("汇源",5);
        map.put("沙市",4);

        map.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println(s+"="+ integer);
            }
        });
        System.out.println("-----------------------------------");

        map.forEach((String s, Integer integer)->{
                System.out.println(s+"="+ integer);
            }
        );
        System.out.println("-----------------------------------");
    }
}

1.5、HashMap

HashMap的特点

  1. HashMap是Map里面的一个实现类。
  2. 没有额外需要学习的特有方法,直接使用Map里面的方法就可以了。
  3. 特点都是由键决定的:无序、不重复、无索引
  4. HashMap跟HashSet底层原理是一模一样的,都是哈希表结构
  5. 依赖hashcode方法和equals方法保证键的唯一
  • 如果存储的是自定义对象,需要重写hashCode和equals方法
  • 如果存储的是自定义对象,不需要重写hashCode和equals方法

1.6、HashMap练习

Java笔记_13(集合进阶2)

package Collection_two_Dome.HashMapDome;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;

public class Dome1 {
    public static void main(String[] args) {
        HashMap<student,String> hm = new HashMap<>();

        student s1 = new student("xiaoming",18);
        student s2 = new student("xiaowang",19);
        student s3 = new student("xiaoli",18);
        student s4 = new student("xiaoming",18);

        hm.put(s1,"henan");
        hm.put(s2,"guangdong");
        hm.put(s3,"jiangsu");
        hm.put(s4,"shandong");

       hm.forEach((student student, String s)->{
                System.out.println(student+" "+s);
            }
        );

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

        Set<Map.Entry<student, String>> hms = hm.entrySet();
        for (Map.Entry<student, String> studentStringEntry : hms) {
            System.out.println(studentStringEntry);
        }

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

        Iterator it = hm.entrySet().iterator();
        while (it.hasNext()){
            Object next = it.next();
            System.out.println(next);
        }

    }
}

Java笔记_13(集合进阶2)

package Collection_two_Dome.HashMapDome;

import java.util.*;

public class Dome2 {
    public static void main(String[] args) {
        //创建数组,记录四个景点
        String[] arr = {"黄山","泰山","华山","佘山"};
        //利用随机数模拟80个同学的投票票
        //通过集合的形式记录每个景点的票数
        Random r =new Random();
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < 80; i++) {
            int index = r.nextInt(arr.length);
            list.add(arr[index]);
        }
        //定义Map集合,利用集合进行统计
        HashMap<String,Integer> hm = new HashMap<>();
        for (String name : list) {
            //判断当前景点在map集合中是否存在
            if(hm.containsKey(name)){
                //先得到这个景点的次数
                int count = hm.get(name);
                //在进行++
                count++;
                //重新存入
                hm.put(name,count);
            }else {
                hm.put(name,1);
            }
        }

        System.out.println(hm);

        //求最大值
        int max = 0;
        //比较得出最大值
        Set<Map.Entry<String, Integer>> entries = hm.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            if(entry.getValue()>max){
                max= entry.getValue();
            }
        }
        System.out.println(max);
        //再次通过遍历的到最大票数的景点

        for (Map.Entry<String, Integer> entry : entries) {
            if (max== entry.getValue()){
                System.out.println(entry.getKey());
            }
        }

    }
}

1.7、HashMap底层源码解析

数组位置为null
Java笔记_13(集合进阶2)
Java笔记_13(集合进阶2)Java笔记_13(集合进阶2)
Java笔记_13(集合进阶2)
Java笔记_13(集合进阶2)Java笔记_13(集合进阶2)
Java笔记_13(集合进阶2)
数组位置不为null,键不重复,挂在下面形成链表或者红黑树
Java笔记_13(集合进阶2)
Java笔记_13(集合进阶2)

1.8、LinkedHashMap

  • 由键决定:有序、不重复、无索引。
  • 这里的有序指的是保证存储和取出的元素顺序一致
  • 原理∶底层数据结构是依然哈希表,只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。

Java笔记_13(集合进阶2)

package Collection_two_Dome.LinkedHashMapDome;

import java.util.LinkedHashMap;

public class Dome1 {
    public static void main(String[] args) {
        LinkedHashMap<String,Integer> linkedHashMap = new LinkedHashMap<>();

        linkedHashMap.put("可乐",3);
        linkedHashMap.put("百事",3);
        linkedHashMap.put("沙市",4);
        linkedHashMap.put("北冰洋",5);
        linkedHashMap.put("可口",3);
        linkedHashMap.put("芬达",3);
        linkedHashMap.put("雪碧",3);
        linkedHashMap.put("可乐",4);//键相同时,回覆盖掉原来的值

        System.out.println(linkedHashMap);
    }
}

1.9、TreeMap

  • TreeMap跟TreeSet底层原理一样,都是红黑树结构的。
  • 由键决定特性:不重复、无索引、可排序
  • 可排序:对键进行排序
  • 注意:默认按照键的从小到大进行排序,也可以自己规定键的排序规则

代码书写两种排序规则

  • 实现Comparable接口,指定比较规则。
  • 创建集合时传递Comparator比较器对象,指定比较规则。
    Java笔记_13(集合进阶2)
package Collection_two_Dome.TreeMapDome;

import java.util.Comparator;
import java.util.TreeMap;

public class Dome1 {
    public static void main(String[] args) {

        TreeMap<Integer,String> tm = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;//此时Integer按照降序排列
            }
        });
        //默认情况下Integer 和Double类型是按照升序的方法进行排列
        tm.put(1,"火车");
        tm.put(4,"游艇");
        tm.put(5,"出租");
        tm.put(2,"公交");
        tm.put(7,"大巴");
        tm.put(6,"汽车");
        tm.put(8,"飞机");

        System.out.println(tm);
    }
}

Java笔记_13(集合进阶2)

package Collection_two_Dome.TreeMapDome;

import java.util.Comparator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Dome2 {
    public static void main(String[] args) {
        TreeMap<Student,String> tm = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int i = o1.getAge()- o2.getAge();
                i = i==0?o1.getName().compareTo(o2.getName()):i;

                return i;
            }
        });

        Student s1 = new Student("chen",18);
        Student s2 = new Student("lu",19);
        Student s3 = new Student("huang",17);
        Student s4 = new Student("jia",19);
        Student s5 = new Student("qian",18);
        Student s6 = new Student("gao",20);


        tm.put(s1,"广东");
        tm.put(s2,"河南");
        tm.put(s3,"四川");
        tm.put(s4,"山西");
        tm.put(s5,"江苏");
        tm.put(s6,"云南");

        Set<Map.Entry<Student, String>> entries = tm.entrySet();
        for (Map.Entry<Student, String> entry : entries) {
            System.out.println(entry);
        }
    }
}
package Collection_two_Dome.TreeMapDome;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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;
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

Java笔记_13(集合进阶2)

package Collection_two_Dome.TreeMapDome;

import java.util.Map;
import java.util.Set;
import java.util.StringJoiner;
import java.util.TreeMap;
import java.util.function.BiConsumer;

public class Dome3 {
    public static void main(String[] args) {

        String s = "asdasdasdasdasdddasdasdaddadfffaasffafasffff";

        TreeMap<Character,Integer> tm = new TreeMap<>();

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if(tm.containsKey(c)){
                Integer count = tm.get(c);
                count++;
                tm.put(c,count);
            }else {
                tm.put(c,1);
            }
        }

        StringBuilder sb = new StringBuilder();

        tm.forEach((character,integer)->sb.append(character).append("(").append(integer).append(")"));
        System.out.println(sb);
        //使用StringJoiner方法时需要定义开头末尾以及中间每个元素之间的间隔字符
        StringJoiner sj  =new StringJoiner("","","");/*使用StringJoiner的add方法时一定要添加字符串&*/
        tm.forEach(( character,  integer)->sj.add(character+"").add("(").add(integer+"").add(")"));
        System.out.println(sj);
    }
}

1.10、TreeMap源码解析

Java笔记_13(集合进阶2)

二、集合练习

2.1、可变参数

  1. 可变参数本质上就是一个数组
  2. 作用:在形参中接收多个数据
  3. 格式:
    • 数据类型...参数名称
    • 举例:int...a
  4. 注意事项:
    • 形参列表中可变参数只能有一个
    • 可变参数必须放在形参列表的最后面
package Collection_two_Dome.Args_Collections;

import com.sun.source.tree.ReturnTree;

public class Dome1 {
    public static void main(String[] args) {
        System.out.println(Addall(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
    }
    public static int Addall(int... a){
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum =  sum + a[i];
        }
        return sum;
    }
}

2.2、Collections

  • java.util.Collections:是集合工具类
  • 作用:Collections不是集合,而是集合的工具类。
方法名称 说明
public static <T> boolean addAll(Collection<T> c,T… elements 批量添加元素
public static void shuffle(List<?> list) 打乱List集合元素的顺序
public static <T> void sort(List<T> list) 排序
public static <T> void sort(List<T> list,comparator<T> c) 根据指定的规则进行排序
public static <T> int binarySearch (List<T> list,T key) 以二分查找法查找元素
public static <T> void copy( List<T> dest,List<T> src) 拷贝集合中的元素
public static <T> int fill (List<T> list,T obj) 使用指定的元素填充集合
public static <T> void max/min(collection<T> coll) 根据默认的自然排序获取最大/小值
public static <T> void swap(List< ?> list,int i, int j) 交换集合中指定位置的元素
package Collection_two_Dome.Args_Collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Dome2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        //在集合里面批量添加元素
        Collections.addAll(list,"asd","qwewq","zxczxc","jghjgh","yuiuyiu","bnmbmn");
        System.out.println(list);
        //打乱集合的顺序
        Collections.shuffle(list);
        System.out.println(list);
        //对集合进行排序(默认是从小到大)
        Collections.sort(list);
        System.out.println(list);
        //按照指定规则对集合进行排序(匿名内部类中重写)
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int i = o2.compareTo(o1);
                return i;
            }
        });
        System.out.println(list);
        //通过二分法进行查找
        System.out.println(Collections.binarySearch(list, "qwewq"));

        //使用该方法必须让被拷贝添加的数组有长度,且大于等于拷贝数组
        Collections.addAll(list2,new String[list.size()]);
        Collections.copy(list2,list);
        System.out.println(list2);
        //获取集合最大值/最小值
        System.out.println(Collections.max(list));
        System.out.println(Collections.min(list));
        //交换集合中指定元素的位置
        Collections.swap(list,0,list.size()-1);
        System.out.println(list);;
        //使用指定元素添加给集合
        Collections.fill(list,"12321");
        System.out.println(list);

    }
}

2.3、综合练习

Java笔记_13(集合进阶2)

package Collection_two_Dome.Exam;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Test1 {
    public static void main(String[] args) {
        //班级里有N个学生,实现随机点名器。
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"xiaoming","xiaowang","xiaohong","xiaoli","xiaozhang","xiaolu","xiaochang");

        Random r = new Random();
        System.out.println(list.get(r.nextInt(list.size())));

        Collections.shuffle(list);
        System.out.println(list.get(r.nextInt(list.size())));

    }
}

Java笔记_13(集合进阶2)

package Collection_two_Dome.Exam;

import java.util.*;

public class Test2 {
    public static void main(String[] args) {
        /*
        班级里有N个学生要求:
            70%的概率随机到男生
            30%的概率随机到女生
        */

        //创建一个集合存放0和1,其中1代表男生,0代表女生
        //这个集合中1的数量为7,0的数量为3
        //随机抽取出来的概率就是男生70%女生30%

        ArrayList<Integer> integers = new ArrayList<>();
        Collections.addAll(integers,1,1,1,1,1,1,1);
        Collections.addAll(integers,0,0,0);

        Random r = new Random();
        int index = integers.get(r.nextInt(integers.size()));

        //创建男生集合
        ArrayList<String> man = new ArrayList<>();
        Collections.addAll(man,"男1","男2","男3","男4","男5","男6","男7","男8");
        //创建女生集合
        ArrayList<String> woman = new ArrayList<>();
        Collections.addAll(woman,"女1","女2","女3","女4","女5","女6","女7","女8");

        if (index == 1){
            System.out.println(man.get(r.nextInt(man.size())));
        } else if (index == 0) {
            System.out.println(woman.get(r.nextInt(man.size())));
        }

    }
}

Java笔记_13(集合进阶2)

package Collection_two_Dome.Exam;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Test3 {
    public static void main(String[] args) {
        /*
        * 班级里有N个学生
        * 要求:
        被点到的学生不会再被点到。
        但是如果班级中所有的学生都点完了,需要重新开启第二轮点名
        * */

        ArrayList<String> list1 = new ArrayList<>();
        //定义一个集合来获取第一个集合删除的元素
        ArrayList<String> list2 = new ArrayList<>();

        Collections.addAll(list1,"xiangwang","xianghuang","xiangli","xiangzhang","xianglu","xiangzhao","xianglong","xiangtian");
        Random r = new Random();

        for (int i = 0; i < 10 ; i++) {
            int count = list1.size();
            for (int j = 0; j < count; j++) {
                //remove(index)该方法会返回删除的结果
                String name  = list1.remove(r.nextInt(list1.size()));
                list2.add(name);
                System.out.println(name);
            }
            //给第list1重新添加回数据,并且清空list2以便重新点名
            list1.addAll(list2);
            list2.clear();
            System.out.println("------------------------------");
        }
    }
}

Java笔记_13(集合进阶2)文章来源地址https://www.toymoban.com/news/detail-427506.html

  • 该案例回到后面完成
    Java笔记_13(集合进阶2)
package Collection_two_Dome.Exam;

import java.util.*;
import java.util.function.BiConsumer;

public class Test4 {
    public static void main(String[] args) {
        HashMap<String, ArrayList<String>> hm = new HashMap<>();

        ArrayList<String> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<String> list3 = new ArrayList<>();
        ArrayList<String> list4 = new ArrayList<>();

        Collections.addAll(list1,"南京市","扬州市","苏州市","镇江市","盐城市","徐州市");
        Collections.addAll(list2,"郑州市","周口市","洛阳市","开封市","商丘市","焦作市");
        Collections.addAll(list3,"广州市","深圳市","东莞市","湛江市","茂名市","汕头市");
        Collections.addAll(list4,"武汉市","鄂州市","黄冈市","孝感市","宜昌市","十堰市");

        hm.put("江苏",list1);
        hm.put("河南",list2);
        hm.put("广东",list3);
        hm.put("湖北",list4);


        Set<Map.Entry<String, ArrayList<String>>> entries = hm.entrySet();
        for (Map.Entry<String, ArrayList<String>> entry : entries) {
            String key = entry.getKey();
            ArrayList<String> value = entry.getValue();
            StringJoiner sj = new StringJoiner(",","","");
            for (String s : value) {
                sj.add(s);
            }
            System.out.println(key+"="+sj);
        }
    }
}

到了这里,关于Java笔记_13(集合进阶2)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 计算机体系结构基础知识介绍之缓存性能的十大进阶优化之小型且简单的一级缓存(二)

    缓存是一种高速的存储器,用于存放处理器经常访问的数据和指令。缓存的组织方式有多种,其中一种是按照不同的关联度(associativity)来划分。关联度表示一个缓存块(block)可以放在缓存中的位置数。关联度越高,缓存中可以容纳的不同块的数量越多,从而减少了冲突不命中

    2024年02月13日
    浏览(45)
  • 【计算机网络笔记】网络应用的体系结构

    什么是计算机网络? 什么是网络协议? 计算机网络的结构 数据交换之电路交换 数据交换之报文交换和分组交换 分组交换 vs 电路交换 计算机网络性能(1)——速率、带宽、延迟 计算机网络性能(2)——时延带宽积、丢包率、吞吐量/率 计算机网络体系结构概念 OSI参考模型

    2024年02月08日
    浏览(49)
  • 1.jvm和java体系结构

    Java是目前应用最为广泛的软件开发平台之一。随着Java以及Java社区的不断壮大Java 也早已不再是简简单单的一门计算机语言了,它更是一个平台、一种文化、一个社区。 ● 作为一个平台,Java虚拟机扮演着举足轻重的作用 ○ Groovy、Scala、JRuby、Kotlin等都是Java平台的一部分 ●

    2024年02月11日
    浏览(52)
  • 计算机体系结构基础知识介绍之缓存性能的十大进阶优化之编译器优化和硬件预取(六)

    处理器和主内存之间不断扩大的性能差距促使编译器编写者仔细检查内存层次结构,看看编译时优化是否可以提高性能。再次,研究分为指令缺失的改进和数据缺失的改进。接下来介绍的优化可以在许多现代编译器中找到。 有些程序具有嵌套循环,以非连续的顺序访问内存中

    2024年02月12日
    浏览(69)
  • 计网笔记 01 概述 计算机网络体系结构、参考模型

    本文为计算机网络第一章:计网体系结构的相关知识点归纳,其中模型参考尤为重要。 1.1.1 概念 其中线路可以是逻辑连接,比如手机通过wifi和路由器相连。 1、信息传递 :比如一台电脑到另一台电脑之间传一个pdf 2、资源共享 :同一个计算机网络上的其他计算机可使用某台

    2024年02月03日
    浏览(81)
  • 嵌入式C语言自我修养笔记1-ARM体系结构与编译运行

    ARM 体系结构 ARM 体系结构 ARM 相对精简指令集 RISC 还有如下区别 ● ARM 有桶型移位寄存器,单周期内可以完成数据的各种移位操作。 ● 并不是所有的 ARM 指令都是单周期的。 ● ARM 有 16 位的 Thumb 指令集,是 32 位 ARM 指令集的压缩形式,提高了代码密度 ● 条件执行:通过指令

    2024年02月07日
    浏览(66)
  • 计算机体系结构基础知识介绍之缓存性能的十大进阶优化之编译器控制的预取和利用HBM扩展内存层次(七)

    硬件预取的替代方案是编译器在处理器需要数据之前插入预取指令来请求数据。 预取有两种类型: ■ 寄存器预取将值加载到寄存器中。 ■ 高速缓存预取仅将数据加载到高速缓存。 这两种类型都可以分为有错或无错的,即预取的地址是否会导致虚拟地址错误或保护错误的异

    2024年02月13日
    浏览(54)
  • 计算机体系结构基础知识介绍之缓存性能的十大进阶优化之减少命中时间和流水线访问和多组缓存增加带宽(三)

    路预测是一种高速缓存优化技术,它在高速缓存中保存额外的位来预测下一次高速缓存访问的路(或者组内的块)。这种预测可以提前设置多路选择器来选择期望的块,并且在那个时钟周期内,只进行一次标记比较,同时读取高速缓存数据。如果预测正确,高速缓存访问延迟

    2024年02月12日
    浏览(47)
  • 【从零开始学JVM】第一章_JVM和java体系结构

    Java是一门跨平台的语言 Java 语言的特点包括: 跨平台性 :Java 程序可以在不同操作系统上运行,只需安装对应平台的 Java 虚拟机(JVM)即可。 面向对象 :Java 是一种纯粹的面向对象编程语言,支持封装、继承、多态等面向对象特性。 健壮性 :Java 在设计时考虑了许多安全检

    2024年02月20日
    浏览(36)
  • 计算机网络笔记:计算机网络体系结构(OSI七层模型、TCP/IP五层协议)

    计算机网络是一个复杂的、具有综合性技术的系统,它由计算机系统、通信处理机、通信线路和通信设备、操作系统以及网络协议等组成。为了更好地描述计算机网络结构,使计算机网络系统有条不紊地处理工作,需要定义一种较好的网络体系结构。分层结构就是一种较好地

    2024年02月07日
    浏览(55)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包