Java集合框架个人总结
Java集合框架个人总结
集合主要分为两大类：①单列集合Collection ②双列集合Map
集合存储的都是引用类型，不可是基础类型，如果保存基础类型需要用包装类。
1.5 泛型 ★
单列集合Collection结构图
Collection接口
集合层次结构中的根界面 。 集合表示一组被称为其元素的对象。 一些集合允许重复元素（Lis），而其他集合不允许（Set）。 有些被命令和其他无序。 JDK不提供此接口的任何直接实现：它提供了更具体的子接口的实现，如Set和List 。 该界面通常用于传递集合，并在需要最大的通用性的情况下对其进行操作。
public class CollectionTest {
public static void main(String[] args) {
//ArrayList 是 Collection的实现类
Collection col = new ArrayList();
String c1 = "张三";
String c2 = "李四";
String c3 = "王五";
//向集合中添加元素 add方法
col.add(c1);
col.add(c2);
col.add(c3);
col.add(c2);
System.out.println(col);
System.out.println(col.size());
//判断集合是否为空和集合是否包含元素
System.out.println(col.contains(c2));
System.out.println(col.contains("王五"));
System.out.println(col.isEmpty());
System.out.println("-----------------------");
//遍历集合
//一、for each方法遍历
for (Object o : col) {
System.out.println((String)o);
//col.remove(o);
}
System.out.println(col);
System.out.println("-----------------------");
//二、Iterator 迭代器迭代遍历
Iterator it = col.iterator();
while (it.hasNext()){
System.out.println(it.next());
it.remove();
}
System.out.println("-----------------------");
col.add(new String("周六"));
System.out.println(col);
}
}
代码说明一：
添加元素add();
清除集合中所有元素clear();
删除集合中指定元素remove();
返回此集合中的元素数size();
返回此集合的迭代器iterator();
注意：在迭代过程中，不可以用remove删除元素；可以用Iterator.remove()删除当前元素。
*** 代码说明二：***
Collection col = new ArrayList(); 和后面的List list = new ArrayList();
在new一个新对象时，左边尽量使用接口（或者抽象类），以保持代码的最大灵活性。
①java是面向对象语言，面向对象一个重要的原则就是“依赖倒置原则”。依赖抽象（接口），而非具体（实现类）。List是接口，ArrayList是实现类。它允许list可以轻松地在接口的不同实现之间切换。
②List的实现类包括List，Vector，LinkedList , Stack…
使用List list = new ArrayList();你将来如果需要改成线程安全的Vector，不必注意一开始使用的是ArrayList还是Vector还是其他的实现类。而是只把创建时使用ArrayList改成Vector就行了。即List list = new Vector();
这种方法实现解耦合，大大提高代码使用的灵活性和通用性。
public class Student {
private String name;
private int 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 Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
}
public class CollectionTest {
public static void main(String[] args) {
//ArrayList 是 Collection的实现类
Collection col = new ArrayList();
Student s1 = new Student("张三",14);
Student s2 = new Student("李四",15);
Student s3 = new Student("王五",16);
//向集合中添加元素 add方法
col.add(s1);
col.add(s2);
col.add(s3);
System.out.println(col);
System.out.println(col.size());
//判断集合是否为空和集合是否包含元素
System.out.println(col.contains(s1));//true
System.out.println(col.contains(new Student("王五",16) ));//true
System.out.println(col.isEmpty());//false
System.out.println("-----------------------");
//遍历集合
//一、for each方法遍历
for (Object o : col) {
System.out.println(o);
// col.remove(o);
}
System.out.println(col);
System.out.println("-----------------------");
//二、Iterator 迭代器迭代遍历
Iterator it = col.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
}
代码说明三：
用contains代码来确定某元素是否属于某个集合和remove从集合中删除某个元素的时候，是调用了该元素对象的Equals方法，如果引用对象的类（Student）中没用重写Equals方法，则默认比较对象的地址是否相同，则上述代码中System.out.println(col.contains(new Student("王五",16) ));应该返回fasle。但是在Student中，重写了Equals方法，添加了用name和age去判断是否为同一个对象，所以System.out.println(col.contains(new Student("王五",16) ));中返回了true。
List子接口（有序、有下标、元素可以重复）
除了继承了collection的所有方法外，List接口的实现类可以用下标去访问元素。
增加方法：
void add(int index, Object o) 在index位置插入对象o
boolean addAll(int index, Collection c) 讲一个集合中的元素添加到此集合中的index位置
Object get(int index) 返回集合中指定位置的元素
List subList(int fromIndex, int toIndex) 返回fromIndex和toIndex之间的集合元素
ListIterator listIterator() 返回List特有的迭代器，可以向前或者向后遍历，添加、删除、修改元素
public class ListTest {
public static void main(String[] args) {
List list = new ArrayList();
String c1 = "张三";
String c2 = "李四";
String c3 = "王五";
//向集合中添加元素 add方法
list.add(c1);
list.add(c2);
list.add(c3);
list.add(c2);
System.out.println(list.toString());
System.out.println(list.size());
//判断集合是否为空和集合是否包含元素
System.out.println(list.contains(c2));
System.out.println(list.contains("王五"));
System.out.println(list.isEmpty());
System.out.println("-----------------------");
//遍历集合
//一、使用for遍历
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("-----------------------");
//二、for each方法遍历
for (Object o : list) {
System.out.println((String)o);
//col.remove(o);
}
System.out.println("-----------------------");
//三、Iterator 迭代器迭代遍历
Iterator it = list.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
System.out.println("-----------------------");
//四、使用列表迭代器
ListIterator lit = list.listIterator();
while (lit.hasNext()){
System.out.println(lit.next());
}
System.out.println("-------------------------");
while (lit.hasPrevious()){
System.out.println(lit.previous());
}
System.out.println(list);
}
}
代码说明：
列表迭代器ListIterator从后向前判断时，必须先运行一边从前向后判断。
ArrayList类
数组结构实现，查询快、增删慢
jdk1.2版本，运行效率快、线程不安全
package com.company.Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class ArrayTest {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
//1.添加元素
Student s1 = new Student("张三",14);
Student s2 = new Student("李四",15);
Student s3 = new Student("王五",16);
arrayList.add(s1);
arrayList.add(s2);
arrayList.add(s3);
System.out.println("元素个数："+arrayList.size());
System.out.println(arrayList.toString());
//2.删除元素
arrayList.remove(s1);
System.out.println("元素个数："+arrayList.size());
System.out.println(arrayList.toString());
//3.遍历元素
//3.1使用迭代器
System.out.println("3.1使用迭代器");
Iterator it = arrayList.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
//3.2使用列表迭代器
System.out.println("3.2使用列表迭代器");
ListIterator lit = arrayList.listIterator();
while (lit.hasNext()){
System.out.println(lit.next());
}
//4判断
System.out.println(arrayList.contains(new Student("王五",16)));
System.out.println(arrayList.isEmpty());
//5查找
System.out.println(arrayList.indexOf(new Student("王五",16)));
System.out.println(arrayList.get(1));
}
}
源码分析：
ArrayList：
默认容量：DEFAULT_CAPACITY = 10； 注意：如果没用向集合中添加任何元素，容量为0。添加任意一个元素之后，容量为10。每次扩容都为原来容量的1.5倍。
存放元素的数组：elementData；
实际元素格式：size；
add添加元素：
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);//10
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
Vector
数组结构实现，查询快、增删慢；
JDK1.0版本，运行效率慢、线程安全。
目前开发使用不多，了解即可。
package com.company.Collection;
import java.util.Enumeration;
import java.util.Vector;
public class VectorTest {
public static void main(String[] args) {
Vector vector = new Vector();
vector.add("北京");
vector.add("上海");
vector.add("深圳");
//遍历
//枚举器
Enumeration en = vector.elements();
while (en.hasMoreElements()){
System.out.println(en.nextElement().toString());
}
//判断
System.out.println(vector.contains("上海"));
//其他方法
System.out.println(vector.firstElement());
System.out.println(vector.lastElement());
}
}
LinkedList
链表结构实现，增删快，查询慢。
存储结构：双向链表。
package com.company.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
public class LinkedListTest {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
//1.添加元素
Student s1 = new Student("张三",14);
Student s2 = new Student("李四",15);
Student s3 = new Student("王五",16);
linkedList.add(s1);
linkedList.add(s2);
linkedList.add(s3);
System.out.println(linkedList.size());
System.out.println(linkedList.toString());
//2.删除元素
// linkedList.remove(s2);
// linkedList.remove(new Student("王五",16));
//3.遍历
//3.1 for 循环
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
//3.2 for each
for (Object o : linkedList) {
System.out.println(((Student)o).toString());
}
//3.3使用迭代器
Iterator it = linkedList.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
//3.4 使用列表迭代器
ListIterator lit = linkedList.listIterator();
while (lit.hasNext()){
System.out.println(lit.next());
}
while (lit.hasPrevious()){
System.out.println(lit.previous());
}
//4 判断
System.out.println(linkedList.contains(s2));
//5 获取
System.out.println(linkedList.indexOf(s1));
System.out.println(linkedList.get(linkedList.indexOf(s1)));
}
}
泛型
泛型类
package com.company.MyGeneric;
/**
* 泛型类
* 语法：类名<T>
* T是占位符，表示一种类型，如果编写多个使用逗号隔开
*/
public class MyGeneric<T>{
//使用泛型T
//1.创建变量
T t;
//2.作为方法的参数
public void show(T t){
System.out.println(t);
}
//3.作为方法的返回值
public T getT(){
return t;
}
}
public class TestGeneric {
public static void main(String[] args) {
MyGeneric<String> myGeneric= new MyGeneric<>();
myGeneric.t="hello";
myGeneric.show("123dadas");
System.out.println(myGeneric.getT());
MyGeneric<Integer> myGeneric2 = new MyGeneric();
myGeneric2.t = 100;
myGeneric2.show(200);
System.out.println(myGeneric2.getT());
}
}
1.泛型只能是引用类型
2.不同泛型类型对象之间不能相互赋值
MyGeneric<Integer> myGeneric3 = myGeneric; //错误的赋值
泛型接口
1.泛型接口的数据类型可以在实现类定义的时候确定
2.泛型接口的数据类型也可以在使用实现类的时候确定
package com.company.MyGeneric;
public interface MyInterface <T>{
String name = "张三";
T server(T t);
}
package com.company.MyGeneric;
public class MyImpl implements MyInterface<String>{
@Override
public String server(String s) {
System.out.println(s);
return s;
}
}
package com.company.MyGeneric;
public class MyImpl2<T> implements MyInterface<T>{
@Override
public T server(T t) {
System.out.println(t.toString());
return t;
}
}
package com.company.MyGeneric;
import com.company.Collection.Student;
public class TestGeneric {
public static void main(String[] args) {
MyImpl my = new MyImpl();
my.server("asdada");
MyImpl2<Student> myImpl2 = new MyImpl2();
myImpl2.server(new Student("李狗",20));
}
}
泛型方法
package com.company.MyGeneric;
public class MyGenericMethod {
//泛型方法
public <T> T show(T t){
System.out.println("泛型方法");
System.out.println(t);
return t;
}
}
package com.company.MyGeneric;
import com.company.Collection.Student;
public class TestGeneric {
public static void main(String[] args) {
MyGenericMethod myGenericMethod = new MyGenericMethod();
myGenericMethod.show(new Student("Dog",23));
}
}
泛型好处
（1）提高代码的重用性
（2）防止类型转换异常，提高代码的去安全性
泛型集合
概念：参数化类型、类型安全的集合，强制集合元素的类型必须一种。
特点：
- 编译时即可检查，而非运行时抛出异常
- 访问时，不必类型转换（拆箱）
- 不同泛型之间引用不能相互赋值，泛型不存在多态
package com.company.Collection;
import java.util.ArrayList;
public class ArrayListTest {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("hello");
arrayList.add("OkFine");
// arrayList.add(123456);
// arrayList.add(new Student("Dog",20));
for (String s : arrayList) {
System.out.println(s);
}
}
}
Set接口
特点：无序、无下标、元素不可重复
package com.company.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class SetTest {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
//1. 添加数据
set.add("苹果");
set.add("香蕉");
set.add("菠萝");
System.out.println(set.size());
System.out.println(set.toString());
//2.删除数据
set.remove("香蕉");
System.out.println(set.toString());
//3. 遍历【重点】
//3.1使用增强for
for (String s : set) {
System.out.println(s);
}
//3.2 使用迭代器
Iterator<String> it = set.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
//判断
System.out.println(set.contains("菠萝"));
}
}
HashSet
- 基于HashCode实现元素不重复
- 当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入
存储结构：哈希表（数组+链表+红黑树）
package com.company.Collection;
import java.util.HashSet;
public class HashSetTest {
public static void main(String[] args) {
//新建集合
HashSet<String> hashSet = new HashSet<>();
hashSet.add("Dog");
hashSet.add("Cat");
hashSet.add("Pig");
System.out.println(hashSet.size());
System.out.println(hashSet.toString());
//遍历 【同Set】
//3.1增强for
//3.2迭代器
//4 判断
System.out.println(hashSet.contains("Cat"));
}
}
HashSet存储过程：
- 根据HashCode计算保存的位置，如果位置为空，则之间保存，如果不为空，则执行第二部
- 再执行equals方法，如果equals 方法为true，则认为是重复的，否者形成链表
package com.company.Collection;
import java.util.Objects;
public class Student {
private String name;
private int 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 Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
int n1 = this.name.hashCode();
int n2 = this.age;
return n1+n2;
}
}
package com.company.Collection;
import java.util.HashSet;
public class HashSetTest2 {
public static void main(String[] args) {
HashSet <Student> hashSet = new HashSet<>();
Student s1 = new Student("张三",23);
Student s2 = new Student("李四",24);
Student s3 = new Student("王五",25);
hashSet.add(s1);
hashSet.add(s2);
hashSet.add(s3);
hashSet.add(new Student("王五",25));
System.out.println(hashSet.size());
System.out.println(hashSet.toString());
}
}
TreeSet
存储结构：红黑树
- 基于排序顺序实现元素不重复
- 实现了SortedSet接口，对集合元素自动排序
- 元素对象的类型必须实现Comparable接口，指定排序规则
- 通过CompareTo方法确定是否为重复元素
package com.company.Collection;
import java.util.TreeSet;
public class TreeSetTest {
public static void main(String[] args) {
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("xyz");
treeSet.add("abc");
treeSet.add("qwe");
System.out.println(treeSet.size());
System.out.println(treeSet.toString());
//遍历 1.使用增强for 2.使用迭代器 同Set
//判断
System.out.println(treeSet.contains("abc"));
}
}
TreeSet使用时，需要满足以下两点中的任一点
- TreeSet集合内的元素实现Comparable接口
package com.company.Collection;
import java.util.Objects;
public class Student implements Comparable<Student>{
private String name;
private int 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 Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
int n1 = this.name.hashCode();
int n2 = this.age;
return n1+n2;
}
//先必n2再比n1
@Override
public int compareTo(Student o) {
int n1 = this.getName().compareTo(o.getName());
int n2 = this.age-o.age;
return n1==0?n2:n1;
}
}
package com.company.Collection;
import java.util.TreeSet;
public class TreeSetTest {
public static void main(String[] args) {
TreeSet<Student> treeSet = new TreeSet<>();
Student s1 = new Student("张三",23);
Student s2 = new Student("李四",24);
Student s3 = new Student("王五",25);
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
System.out.println(treeSet.size());
}
}
- 实现定制比较Comparator（比较器）
package com.company.Collection;
import java.util.Comparator;
import java.util.TreeSet;
public class TreeSetTest {
public static void main(String[] args) {
TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int n1 = o1.getAge()-o2.getAge();
int n2 = o1.getName().compareTo(o2.getName());
return n1==0?n2:n1;
}
});
Student s1 = new Student("张三",23);
Student s2 = new Student("李四",24);
Student s3 = new Student("王五",25);
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
System.out.println(treeSet.size());
}
}
Map父接口
特点：存储一堆数据（key-Value）,无序，无下标，键不可重复，值可重复。
方法：
- V put（K Key， V value）//将对象存入到集合中
- Object get（Object key） //根据键获取对应的值
- Set<K> //返回所有的key
- Collection<K> values() //返回包含所有值的Collection集合。
- Set<Map.Entry<K,V>> //键值匹配的Set集合
遍历时EntrySet效率高于Set
package com.company.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapTest {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("China", "中国");
map.put("America", "美国");
map.put("Uk", "英国");
System.out.println(map.size());
System.out.println(map.toString());
//遍历
//1.使用ketSet()
Set<String> set = map.keySet();
for (String s : set) {
System.out.println(s+"="+map.get(s));
}
//2.使用entrySet()
Set<Map.Entry<String,String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry.getKey()+"="+entry.getValue());
}
}
}
HashMap
jdk1.2版本，线程不安全，运行效率快；允许使用null作为key或者是value。
默认加载容量15，默认加载因子0.75
使用Key的hashcode和equals作为重复
package com.company.Collection;
import java.util.HashMap;
public class HashMapTest {
public static void main(String[] args) {
HashMap<Student,String> students = new HashMap<>();
Student s1 = new Student("张三",23);
Student s2 = new Student("李四",24);
Student s3 = new Student("王五",25);
students.put(s1, "北京");
students.put(s2, "上海");
students.put(s3, "深圳");
students.put(new Student("王五",25),"深圳");
System.out.println(students.size());
System.out.println(students.toString());
}
}
Student类中重新了hashcode和equals函数，以年龄和姓名的值作为比较是否相同。上面程序输出：
3
源码分析
- HashMap刚创建时，table是null，为了节省空间，当添加第一个元素时，table容量调整为16
- 当元素个数大于阈值（16-0.75）=12时，会进行扩容，扩容大小为原来的2倍。目的是减少调整元素的个数。
- jdk1.8，当每个链表长度大于8，并且数组元素个数大于64时，会调整为红黑树，目的是提高执行效率
- jdk1.8，当链表长度小于6时，调整成链表
- jdk1.8以前，链表是头插入，jdk1.8以后是尾插入
Hashtable
- JDK1.0版本，线程安全，运行效率慢；不允许null作为key或是value。
目前用的不多。
Properties
- Hashtable的子类，要求key和value都是String。通常用于配置文件的读取。
主要用于流的操作。
TreeMap
- 实现了SortedMap接口（是）Map的子接口，可以对Key自动排序。
package com.company.Collection;
import java.util.Comparator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapTest {
public static void main(String[] args) {
TreeMap<Student,String> students = new TreeMap<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int n2 = o1.getAge()-o2.getAge();
int n1 = o1.getName().compareTo(o2.getName());
return n1==0?n2:n1;
}
});
Student s1 = new Student("张三",23);
Student s2 = new Student("李四",24);
Student s3 = new Student("王五",25);
students.put(s1, "北京");
students.put(s2, "上海");
students.put(s3, "深圳");
System.out.println(students.size());
System.out.println(students.toString());
//遍历
//1.keyset遍历
Set<Student> set = students.keySet();
for (Student student : set) {
System.out.println(student+"="+students.get(student));
}
//2.entryset()遍历
Set<Map.Entry<Student,String>> entries=students.entrySet();
for (Map.Entry<Student, String> entry : entries) {
System.out.println(entry.getKey()+"="+entry.getValue());
}
}
}
Collections工具类
package com.company.Collection;
import java.lang.reflect.Array;
import java.util.*;
public class CollectionsTest {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(200);
list.add(250);
list.add(300);
list.add(12);
System.out.println("排序之前"+list.toString());
Collections.sort(list);
System.out.println("排序之后"+list.toString());
//二分查找
int i = Collections.binarySearch(list, 200);
System.out.println(i);
//负值
List<Integer> list1 = new ArrayList<>();
for (int i1 = 0; i1 < list.size(); i1++) {
list1.add(0);
}
Collections.copy(list1, list);
System.out.println(list1.toString());
//反转
Collections.reverse(list);
System.out.println("反转之后"+list.toString());
//打乱
Collections.shuffle(list);
System.out.println("打乱之后"+list.toString());
//补充：list转为数组
Integer[] i1 = list.toArray(new Integer[0]);
System.out.println(i1.length);
System.out.println(Arrays.toString(i1));
//数组变为集合
String[] names = {"张三","李四","王五"};
List<String> list2 = Arrays.asList(names);
//集合是一个受限集合，不能添加删除
System.out.println(list2);
}
}
Java集合框架个人总结的更多相关文章
- Java集合框架List，Map，Set等全面介绍
Java集合框架的基本接口/类层次结构: java.util.Collection [I]+--java.util.List [I] +--java.util.ArrayList [C] +- ...
- Java集合框架练习-计算表达式的值
最近在看<算法>这本书,正好看到一个计算表达式的问题,于是就打算写一下,也正好熟悉一下Java集合框架的使用,大致测试了一下,没啥问题. import java.util.*; /* * ...
- 【集合框架】Java集合框架综述
一.前言 现笔者打算做关于Java集合框架的教程,具体是打算分析Java源码,因为平时在写程序的过程中用Java集合特别频繁,但是对于里面一些具体的原理还没有进行很好的梳理,所以拟从源码的角度去熟悉梳 ...
- Java 集合框架
Java集合框架大致可以分为五个部分:List列表,Set集合.Map映射.迭代器.工具类 List 接口通常表示一个列表(数组.队列.链表 栈),其中的元素 可以重复 的是:ArrayList 和L ...
- Java集合框架之map
Java集合框架之map. Map的主要实现类有HashMap,LinkedHashMap,TreeMap,等等.具体可参阅API文档. 其中HashMap是无序排序. LinkedHashMap是自 ...
- 22章、Java集合框架习题
1.描述Java集合框架.列出接口.便利抽象类和具体类. Java集合框架支持2种容器:(1) 集合(Collection),存储元素集合 (2)图(Map),存储键值对.
- Java集合框架实现自定义排序
Java集合框架针对不同的数据结构提供了多种排序的方法,虽然很多时候我们可以自己实现排序,比如数组等,但是灵活的使用JDK提供的排序方法,可以提高开发效率,而且通常JDK的实现要比自己造的轮子性能更优 ...
- （转）Java集合框架：HashMap
来源:朱小厮 链接:http://blog.csdn.net/u013256816/article/details/50912762 Java集合框架概述 Java集合框架无论是在工作.学习.面试中都 ...
- Java集合框架
集合框架体系如图所示 Java 集合框架提供了一套性能优良,使用方便的接口和类,java集合框架位于java.util包中, 所以当使用集合框架的时候需要进行导包. Map接口的常用方法 Map接口提 ...
- Java集合框架（常用类） JCF
Java集合框架(常用类) JCF 为了实现某一目的或功能而预先设计好一系列封装好的具有继承关系或实现关系类的接口: 集合的由来: 特点:元素类型可以不同,集合长度可变,空间不固定: 管理集合类和接口 ...
随机推荐
- 快速搭建maven私服仓库并配置
1.第一步,通过官方网站下载tar.gz包上传到服务器并解压 随后进入解压目录,并执行./bin/nexus start 此时可能会出现如下异常 处理这个问题很容易,找到bin下的nexus文件,vi ...
- DevExpress各大版本支持的VS版本和支持的.net版本图
如下图所示,绿色Yes代表支持,红色No代表不支持.对于有些人觉得装了dev后,vs工具箱没有,一般都是以下两大问题:1.要么你的Dev的版本不支持你当前的VS版本,没有很正常.2.要么你的项目的.n ...
- Bug_Android error: duplicate attribute. (错误：重复属性。)
error: duplicate attribute. 错误:重复属性. 如报错信息提示,属性重复赋值了 场景:刚拿到项目源码,进行修改前,先设置它的背景色,区分是哪一块内容,但没看到组件已定义了背景 ...
- P1982 [NOIP2013 普及组] 小朋友的数字 题解
目录 简单版 题目 code 本题 code 简单版 先要会做这道题 题目 P1115 最大子段和https://www.luogu.com.cn/problem/P1115 这道题其实是动态规划,d ...
- 312. 戳气球 (Hard)
问题描述 312. 戳气球 (Hard) 有 n 个气球,编号为 0 到 n - 1,每个气球上都标有一个数字,这些数字存在数组 nums 中. 现在要求你戳破所有的气球.戳破第 i 个气球,你可以获 ...
- UCF Local Programming Contest 2018 C. First Last Sorting 思维、简单DP
C. First Last Sorting链接:https://nanti.jisuanke.com/t/44141
- Rsync等传统文件同步方式已过时 如何寻找替代产品？
Rsync原本是在Linux系统下面的一个文件同步协议,随着技术的发展,它也有其它版本的,如Windows和AIX.HPUX下面都有相应的版本可以支持的.它有很多版本都是免费的,配置也不复杂,所以很多 ...
- python如何提取word内的图片
解压.docx文件实现提取图片 前言 .docx文件其实也就是一个压缩文件,当我们将一个.docx文件直接解压后可以看到如下目录 其中我们要找的图片就在word/media目录内,如图 所以,要提取w ...
- mqtt安装和使用
linux下 下载: wget https://www.emqx.io/downloads/broker/v3.2.1/emqx-centos7-v3.2.1.zip 解压:unzip emqx-ce ...
- win10禁用自带键盘
本文转载:https://blog.csdn.net/BiandanLoveyou/article/details/1163550041.不要相信网上说的那种在控制面板更换驱动,禁用什么设备,没卵用, ...