java基础系列:集合入门
集合框架:
Java中的集合框架大类可分为Collection和Map;两者的区别:
Collection是单列集合;Map是双列集合
Collection中只有Set系列要求元素唯一;Map中键需要唯一,值可以重复
Collection的数据结构是针对元素的;Map的数据结构是针对键的。
泛型:
在说两大集合体系之前先说说泛型,因为在后面的集合中都会用到;
所谓的泛型就是:类型的参数化
泛型是类型的一部分,类名+泛型是一个整体
如果有泛型,不使用时,参数的类型会自动提升成Object类型,如果再取出来的话就需要向下强转,就可能发生类型转化异常(ClassCaseException);不加泛型就不能在编译期限定向集合中添加元素的类型,导致后期的处理麻烦。
下面就来对比加了泛型和不加泛型的区别:
package 好好学java;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class Test {public static void main(String[] args) {// 不加泛型,添加和遍历List list = new ArrayList<>();list.add(1);list.add("123");list.add("hello");Iterator it = list.iterator();while(it.hasNext()){// 没有添加泛型,这里只能使用Object接收Object obj = it.next();System.out.println(obj);}}}
package 好好学java;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class Test {public static void main(String[] args) {// 加泛型,添加和遍历List<String> list = new ArrayList<String>();list.add("123");list.add("hello");Iterator<String> it = list.iterator();while(it.hasNext()){// 因为添加了泛型,就说明集合中装的全部都是String类型的数据// 所以这里用String类型接收,就不会发生异常,并且可以使用String的方法String str = it.next();System.out.println(str.length());}}}
自定义带泛型的类:
package 好好学java;public class Test {// 自定义一个带有一个参数的泛型类,可以向传入什么类型就传入什么类型public static void main(String[] args) {// 进行测试, 传入一个String对象Person<String> perStr = new Person<String>();perStr.setT("我是字符串");String str = perStr.getT();System.out.println(str);// 进行测试,传入一个Integer对象Person<Integer> perInt = new Person<Integer>();perInt.setT(100);Integer intVal = perInt.getT();System.out.println(intVal);}}
//自定义一个带有一个参数的泛型类
class Person<T>{private T t;void setT(T t){this.t = t;}T getT(){return t;}
}
实现带有泛型的接口类型:
实现接口的同时, 指定了接口中的泛型类型. (定义类时确定);
public class GenericImpl1 implements GenericInter<String> {}
实现接口时, 没有指定接口中的泛型类型.此时, 需要将该接口的实现类定义为泛型类.接口的类型需要在创建实现类对象时才能真正确定其类型. (始终不确定类型, 直到创建对象时确定类型);
public class GenericImpl2<T> implements GenericInter<T> {}
泛型的通配符(?):
上限限定:比如定义方法的时候出现,public void getFunc(List<? extends Animal> an),
那么表示这里的参数可以传入Animal,或者 Animal的子类
下限限定: 比如定义方法的时候出现,public void getFunc(Set<? super Animal> an ),
那么表示这里的参数可以传入Animal,或者Animal的父类
使用泛型的注意点:
1、泛型不支持基本数据类型
2、泛型不支持继承,必须保持前后一致(比如这样是错误的:List<Object> list = new ArrayList<String>();
Collection体系:
ollection包括两大体系,List和Set
List的特点:
存取有序,有索引,可以根据索引来进行取值,元素可以重复
Set的特点:
存取无序,元素不可以重复
List:
下面有ArrayList,LinkedList,Vector
(已过时)
集合的的最大目的就是为了存取;List集合的特点就是存取有序,可以存储重复的元素,可以用下标进行元素的操作
ArrayList: 底层是使用数组实现,所以查询速度快,增删速度慢
package 好好学java;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class Test {// 使用ArrayList进行添加和遍历public static void main(String[] args) {List<String> list = new ArrayList<String>();list.add("接口1");list.add("接口2");list.add("接口3");// 第一种遍历方式,使用迭代器Iterator<String> it = list.iterator();while(it.hasNext()){String next = it.next();System.out.println(next);}System.out.println("-------------------");// 第二种遍历方式,使用foreachfor (String str : list){System.err.println(str);}}}
LinkedList:是基于链表结构实现的,所以查询速度慢,增删速度快,提供了特殊的方法,对头尾的元素操作(进行增删查)。
使用LinkedList来实现栈和队列;栈是先进后出,而队列是先进先出
package com.xiaoshitou.classtest;import java.util.LinkedList;/*** 利用LinkedList来模拟栈* 栈的特点:先进后出* @author Beck**/
public class MyStack {private LinkedList<String> linkList = new LinkedList<String>();// 压栈public void push(String str){linkList.addFirst(str);}// 出栈public String pop(){return linkList.removeFirst();}// 查看public String peek(){return linkList.peek();}// 判断是否为空public boolean isEmpty(){return linkList.isEmpty();}
}package 好好学java;public class Test {public static void main(String[] args) {// 测试栈StackTest stack = new StackTest();stack.push("我是第1个进去的");stack.push("我是第2个进去的");stack.push("我是第3个进去的");stack.push("我是第4个进去的");stack.push("我是第5个进去的");// 取出while (!stack.isEmpty()){String pop = stack.pop();System.out.println(pop);}// 打印结果/*我是第5个进去的我是第4个进去的我是第3个进去的我是第2个进去的我是第1个进去的*/}}
LinkedList实现Queue:
package 好好学java;import java.util.LinkedList;/*** 利用linkedList来实现队列* 队列: 先进先出* @author Beck**/
public class QueueTest {private LinkedList<String> link = new LinkedList<String>();// 放入public void put(String str){link.addFirst(str);}// 获取public String get(){return link.removeLast();}// 判断是否为空public boolean isEmpty(){return link.isEmpty();}
}
package 好好学java;public class Test {public static void main(String[] args) {// 测试队列QueueTest queue = new QueueTest();queue.put("我是第1个进入队列的");queue.put("我是第2个进入队列的");queue.put("我是第3个进入队列的");queue.put("我是第4个进入队列的");// 遍历队列while (!queue.isEmpty()){String str = queue.get();System.out.println(str);}// 打印结果/*我是第1个进入队列的我是第2个进入队列的我是第3个进入队列的我是第4个进入队列的*/}}
Vector:因为已经过时,被ArrayList取代了;它还有一种迭代器通过vector.elements()获取,判断是否有元素和取元素的方法为:hasMoreElements(),nextElement()
。
package 好好学java;import java.util.Enumeration;
import java.util.Vector;public class Test {public static void main(String[] args) {Vector<String> vector = new Vector<String>();vector.add("搜索");vector.add("vector");vector.add("list");Enumeration<String> elements = vector.elements();while (elements.hasMoreElements()){String nextElement = elements.nextElement();System.out.println(nextElement);}}}
Set:
Set集合的特点:元素不重复,存取无序,无下标
Set集合下面有:HashSet,LinkedHashSet,TreeSet
HashSet存储字符串:
package 好好学java;import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;public class Test {public static void main(String[] args) {// 利用HashSet来存取Set<String> set = new HashSet<String>();set.add("我的天");set.add("我是重复的");set.add("我是重复的");set.add("welcome");// 遍历 第一种方式 迭代器Iterator<String> it = set.iterator();while(it.hasNext()){String str = it.next();System.out.println(str);}System.out.println("--------------");for (String str : set){System.out.println(str);}// 打印结果,重复的已经去掉了/*我的天welcome我是重复的--------------我的天welcome我是重复的*/}
那哈希表是怎么来保证元素的唯一性的呢,哈希表是通过hashCode和equals方法来共同保证的。
哈希表的存储数据过程(哈希表底层也维护了一个数组):
根据存储的元素计算出hashCode值,然后根据计算得出的hashCode值和数组的长度进行计算出存储的下标;如果下标的位置无元素,那么直接存储;如果有元素,那么使用要存入的元素和该元素进行equals方法,如果结果为真,则已经有相同的元素了,所以直接不存;如果结果假,那么进行存储,以链表的形式存储。
演示HashSet来存储自定义对象:
package 好好学java;public class Person {// 属性private String name;private int age;// 构造方法public Person() {super();}public Person(String name, int age) {super();this.name = name;this.age = age;}// 要让哈希表存储不重复的元素,就必须重写hasCode和equals方法@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Person other = (Person) obj;if (age != other.age)return false;if (name == null) {if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}// getter & setter...}package 好好学java;import java.util.HashSet;
import java.util.Set;public class Test {public static void main(String[] args) {// 利用HashSet来存取自定义对象 PersonSet<Person> set = new HashSet<Person>();set.add(new Person("cy", 12));set.add(new Person("李四", 13));set.add(new Person("王五", 22));set.add(new Person("cy", 12));// 遍历for (Person p : set){System.out.println(p);}// 结果:向集合中存储两个cy对象,但是集合中就成功存储了一个/*Person [name=王五, age=22]Person [name=李四, age=13]Person [name=cy, age=12]*/}}
所以在向HashSet集合中存储自定义对象时,为了保证set集合的唯一性,那么必须重写hashCode和equals方法。
LinkedHashSet:
是基于链表和哈希表共同实现的,所以具有存取有序,元素唯一
package 好好学java;import java.util.LinkedHashSet;public class Test {public static void main(String[] args) {// 利用LinkedHashSet来存取自定义对象 PersonLinkedHashSet<Person> set = new LinkedHashSet<Person>();set.add(new Person("cy", 12));set.add(new Person("李四", 13));set.add(new Person("王五", 22));set.add(new Person("cy", 12));// 遍历for (Person p : set){System.out.println(p);}// 结果:向集合中存储两个cy对象,但是集合中就成功存储了一个,// 并且存进的顺序,和取出来的顺序是一致的/*Person [name=cy, age=12]Person [name=李四, age=13]Person [name=王五, age=22]*/}}
TreeSet:
特点:存取无序,元素唯一,可以进行排序(排序是在添加的时候进行排序)。
TreeSet是基于二叉树的数据结构,二叉树的:一个节点下不能多余两个节点。
二叉树的存储过程:
如果是第一个元素,那么直接存入,作为根节点,下一个元素进来是会跟节点比较,如果大于节点放右边的,小于节点放左边;等于节点就不存储。后面的元素进来会依次比较,直到有位置存储为止
TreeSet集合存储String对象
package 好好学java;import java.util.TreeSet;public class Test {public static void main(String[] args) {TreeSet<String> treeSet = new TreeSet<String>();treeSet.add("abc");treeSet.add("zbc");treeSet.add("cbc");treeSet.add("xbc");for (String str : treeSet){System.out.println(str);}// 结果:取出来的结果是经过排序的/*abccbcxbczbc*/}}
TreeSet保证元素的唯一性是有两种方式:
1、自定义对象实现Comparable接口,重写comparaTo方法,该方法返回0表示相等,小于0表示准备存入的元素比被比较的元素小,否则大于0;
2、在创建TreeSet的时候向构造器中传入比较器Comparator接口实现类对象,实现Comparator接口重写compara方法。
如果向TreeSet存入自定义对象时,自定义类没有实现Comparable接口,或者没有传入Comparator比较器时,会出现ClassCastException异常
下面就是演示用两种方式来存储自定义对象
package 好好学java;
public class Person implements Comparable<Person>{// 属性private String name;private int age;// 构造方法public Person() {super();}public Person(String name, int age) {super();this.name = name;this.age = age;}// 要让哈希表存储不重复的元素,就必须重写hasCode和equals方法@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Person other = (Person) obj;if (age != other.age)return false;if (name == null) {if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}// getter & setter...@Overridepublic int compareTo(Person o) {int result = this.age - o.age;if (result == 0){return this.name.compareTo(o.name);}return result;}}package 好好学java;import java.util.TreeSet;public class Test {public static void main(String[] args) {// 利用TreeSet来存储自定义类Person对象TreeSet<Person> treeSet = new TreeSet<Person>();// Person类实现了Comparable接口,并且重写comparaTo方法// 比较规则是先按照 年龄排序,年龄相等的情况按照年龄排序treeSet.add(new Person("张山1", 20));treeSet.add(new Person("张山2", 16));treeSet.add(new Person("张山3", 13));treeSet.add(new Person("张山4", 17));treeSet.add(new Person("张山5", 20));for (Person p : treeSet){System.out.println(p);}// 结果:按照comparaTo方法内的逻辑来排序的/*Person [name=张山3, age=13]Person [name=张山2, age=16]Person [name=张山4, age=17]Person [name=张山1, age=20]Person [name=张山5, age=20]*/}}
另一种方式:使用比较器Comparator
package 好好学java;public class Person{// 属性private String name;private int age;// 构造方法public Person() {super();}public Person(String name, int age) {super();this.name = name;this.age = age;}// 要让哈希表存储不重复的元素,就必须重写hasCode和equals方法@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Person other = (Person) obj;if (age != other.age)return false;if (name == null) {if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}// getter & setter...}package 好好学java;import java.util.Comparator;
import java.util.TreeSet;public class Test {public static void main(String[] args) {// 利用TreeSet来存储自定义类Person对象// 创建TreeSet对象的时候传入Comparator比较器,使用匿名内部类的方式// 比较规则是先按照 年龄排序,年龄相等的情况按照年龄排序TreeSet<Person> treeSet = new TreeSet<Person>(new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {if (o1 == o2){return 0;}int result = o1.getAge() - o2.getAge();if (result == 0){return o1.getName().compareTo(o2.getName());}return result;}});treeSet.add(new Person("张山1", 20));treeSet.add(new Person("张山2", 16));treeSet.add(new Person("张山3", 13));treeSet.add(new Person("张山4", 17));treeSet.add(new Person("张山5", 20));for (Person p : treeSet){System.out.println(p);}// 结果:按照compara方法内的逻辑来排序的/*Person [name=张山3, age=13]Person [name=张山2, age=16]Person [name=张山4, age=17]Person [name=张山1, age=20]Person [name=张山5, age=20]*/}}
比较器总结:
Collection体系总结:
List : “特点 :” 存取有序,元素有索引,元素可以重复.
ArrayList : 数组结构,查询快,增删慢,线程不安全,因此效率高.
Vector : 数组结构,查询快,增删慢,线程安全,因此效率低.
LinkedList : 链表结构,查询慢,增删快,线程不安全,因此效率高.
addFirst() removeFirst() getFirst()
Set :”特点 :” 存取无序,元素无索引,元素不可以重复.
HashSet : 存储无序,元素无索引,元素不可以重复.底层是哈希表.
请问 : 哈希表如何保证元素唯一呢 ? 底层是依赖 hashCode 和 equals 方法.
当存储元素的时候,先根据 hashCode + 数组长度 计算出一个索引,判断索引位置是否有元素.
如果没有元素,直接存储,如果有元素,先判断 equals 方法,比较两个元素是否相同,不同则存储,相同则舍弃.
我们自定义对象存储的元素一定要实现 hashCode 和 equals.
LinkedHashSet : 存储有序,元素不可以重复.
TreeSet : 存取无序, 但是可以排序 (自然排序), 元素不可以重复.
有两种排序方式 :
- 自然排序 :
我们的元素必须实现 Comparable 接口.可比较的.实现 CompareTo 方法.
- 比较器排序 :
我们需要自定义类,实现Comparetor接口,这个类就是比较器实现 compare 方法.
然后在创建 TreeSet 的时候,把比较器对象作为参数传递给 TreeSet.
Map:
Map是一个双列集合,其中保存的是键值对,键要求保持唯一性,值可以重复
键值是一一对应的,一个键只能对应一个值
Map的特点:是存取无序,键不可重复
Map在存储的时候,将键值传入Entry,然后存储Entry对象
其中下面有HashMap,LinkedHashMap和TreeMap
HashMap:
是基于哈希表结构实现的,所以存储自定义对象作为键时,必须重写hasCode和equals方法。存取无序的
下面演示HashMap以自定义对象作为键:
package 好好学java;import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;public class Test {public static void main(String[] args) {// 利用HashMap存储,自定义对象Person作为键// 为了保证键的唯一性,必须重写hashCode和equals方法HashMap<Person,String> map = new HashMap<Person,String>();map.put(new Person("cy", 12), "JAVA");map.put(new Person("李四", 13), "IOS");map.put(new Person("小花", 22), "JS");map.put(new Person("sihai", 32), "PHP");map.put(new Person("cy", 12), "C++");Set<Entry<Person, String>> entrySet = map.entrySet();Iterator<Entry<Person, String>> it = entrySet.iterator();while (it.hasNext()){Entry<Person, String> entry = it.next();System.out.println(entry.getKey() + "---" + entry.getValue());}// 结果:存入的时候添加了两个cy,如果Map中键相同的时候,当后面的值会覆盖掉前面的值/*Person [name=李四, age=13]---IOSPerson [name=cy, age=12]---C++Person [name=sihai, age=32]---PHPPerson [name=小花, age=22]---JS*/}}
LinkedHashMap:
用法跟HashMap基本一致,它是基于链表和哈希表结构的所以具有存取有序,键不重复的特性
下面演示利用LinkedHashMap存储,注意存的顺序和遍历出来的顺序是一致的:
package 好好学java;import java.util.LinkedHashMap;
import java.util.Map.Entry;public class Test {public static void main(String[] args) {// 利用LinkedHashMap存储,自定义对象Person作为键// 为了保证键的唯一性,必须重写hashCode和equals方法LinkedHashMap<Person,String> map = new LinkedHashMap<Person,String>();map.put(new Person("cy", 12), "JAVA");map.put(new Person("李四", 13), "IOS");map.put(new Person("小花", 22), "JS");map.put(new Person("sihai", 32), "PHP");map.put(new Person("cy", 12), "C++");// foreach遍历for (Entry<Person,String> entry : map.entrySet()){System.out.println(entry.getKey()+"==="+entry.getValue());}// 结果:存入的时候添加了两个cy,如果Map中键相同的时候,当后面的值会覆盖掉前面的值// 注意:LinkedHashMap的特点就是存取有序,取出来的顺序就是和存入的顺序保持一致/*Person [name=cy, age=12]===C++Person [name=李四, age=13]===IOSPerson [name=小花, age=22]===JSPerson [name=sihai, age=32]===PHP*/}
}
TreeMap:
给TreeMap集合中保存自定义对象,自定义对象作为TreeMap集合的key值。由于TreeMap底层使用的二叉树,其中存放进去的所有数据都需要排序,要排序,就要求对象具备比较功能。对象所属的类需要实现Comparable接口。或者给TreeMap集合传递一个Comparator接口对象。
利用TreeMap存入自定义对象作为键:
package 好好学java;import java.util.Comparator;
import java.util.Map.Entry;
import java.util.TreeMap;public class Test {public static void main(String[] args) {// 利用TreeMap存储,自定义对象Person作为键// 自定义对象实现Comparable接口或者传入Comparator比较器TreeMap<Person,String> map = new TreeMap<Person,String>(new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {if (o1 == o2){return 0;}int result = o1.getAge() - o2.getAge();if (result == 0){return o1.getName().compareTo(o2.getName());}return result;}});map.put(new Person("cy", 12), "JAVA");map.put(new Person("李四", 50), "IOS");map.put(new Person("小花", 32), "JS");map.put(new Person("sihai", 32), "PHP");map.put(new Person("cy", 12), "C++");// foreach遍历for (Entry<Person,String> entry : map.entrySet()){System.out.println(entry.getKey()+"==="+entry.getValue());}// 结果:存入的时候添加了两个cy,如果Map中键相同的时候,当后面的值会覆盖掉前面的值// 注意:TreeMap 取出来的顺序是经过排序的,是根据compara方法排序的/*Person [name=cy, age=12]===C++Person [name=小花, age=32]===JSPerson [name=sihai, age=32]===PHPPerson [name=李四, age=50]===IOS*/}
}
java基础系列:集合入门相关推荐
- 夯实Java基础系列9:深入理解Class类和Object类
本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下 ...
- 夯实Java基础系列22:一文读懂Java序列化和反序列化
本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下 ...
- 夯实Java基础系列14:深入理解Java枚举类
本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下 ...
- 夯实Java基础系列19:一文搞懂Java集合类框架,以及常见面试题
本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下 ...
- 夯实Java基础系列6:一文搞懂抽象类和接口,从基础到面试题,揭秘其本质区别!
本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下 ...
- 夯实Java基础系列17:一文搞懂Java多线程使用方式、实现原理以及常见面试题
本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下 ...
- 夯实Java基础系列1:Java面向对象三大特性(基础篇)
本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下 ...
- string substring的用法_夯实Java基础系列3:一文搞懂String常见面试题,从基础到实战...
本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下 ...
- java中this_夯实Java基础系列7:一文读懂Java 代码块和执行顺序
目录 #java中的构造方法 #构造方法简介 #构造方法实例 #例-1 #例-2 #java中的几种构造方法详解 #普通构造方法 #默认构造方法 #重载构造方法 #java子类构造方法调用父类构造方法 ...
- [转载] 夯实Java基础系列8:深入理解Java内部类及其实现原理
参考链接: Java内部类 本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tut ...
最新文章
- IOS个人开发者账号注册
- C#的网络适配器操作
- xutils,afinal的数据库升级要注意的地方
- php mysql 全文检索_MySQL中文全文检索
- JavaScript 中 substr 和 substring的区别
- 树-堆结构练习——合并果子之哈夫曼树(是最优二叉树题目的缩影)
- php sqlite存入文件夹,PHP_小文件php+SQLite存储方案,我们草根站长购买的虚拟主机 - phpStudy...
- OpenCV案例(二):选取圆对象
- 2011 微软MVP全球峰会美国行之飞离北京
- (12)数据结构-二叉树基本操作
- Windows 下 git的安装 + 可视化的小乌龟的安装
- 如何下载东四街道卫星地图高清版大图?
- 为什么边缘概率密度是联合概率密度的积分_解读奥运积分排名:石宇奇为何第13 林丹谌龙未入前16...
- VMware虚拟机Ubuntu自适应屏幕大小
- Rstudio(4.0.5 )安装Rtool40
- 关于死亡最温暖的解答
- 乐视 无法播放服务器文件夹,乐视电视最新常见问题及解决方法分享!
- Windows 批量创建用户
- PMP-项目整合管理的内容
- 探究计算机的硬件组成 教案,初一信息技术探究计算机的硬件组成教案