Java个人学习心得之集合篇

一、集合

1、集合的内容

1.1、集合中存的是引用，不是对象。

1.2、集合的底层是数据结构，也就是说，往不同的集合里面存储元素，等于将数据放到了不同的数据结构中。

1.3、数据存储的结构就是数据结构，不同的数据结构存储的方式不同，例如：数组、二叉树、链表、哈希表，但在java中，你只需要掌握如何去用就好。

new ArrayList();//创建的是一个集合对象，底层是数组array
new Linkelist();//创建的是一个集合对象，底层是链表linke
new TreeSET();//创建的是一个集合对象，底层是二叉树
...

1.4、集合在java.util.*；下，所有的集合类和集合接口都在这个包下

1.5、背会集合的继承结构图

2、在java中集合分为两大类：

2.1、单个方式存储元素：

2.2、单个存储元素，这一类集合中超级父接口是：**

java.util.Collection；

重点：

Iterator it ="Collection 对象".iterator();

• it是迭代器 ，add（）了新的元素，必须要重新在下面创建一个迭代器。

• 元素发生过改变，迭代器必须重新创建

• 在while中使用remove删除的元素时候，一般使用迭代器。remove来删除元素

所有集合继承iterable的含义是：所有集合都是可迭代的。

2.3、**Collection集合下面有两个子接口List集合和Set集合：

**list集合：**有序可重复，存储的元素有下标，存进去是这个顺序取出来还是这个顺序，不是大小排列的。

**set集合：**无序不可重复，存储的元素没有下表。存进去是这个顺去，取出来就不一定是这个顺序了。

常用的有三个类去实现List接口（new的是这些类）：

**1、ArrayList：**该集合底层采用了数组这种数据结构（是非线程安全的）

2、LinkeList：该集合底层采用双向链表数据结构

**3、Vector：**该集合底层采用数组数据结构（是线程安全的），Verctor所有的方法都有synchronized关键字修饰，所以线程安全，但是效率较低，现在保护线程安全有别的方案，所以vector使用较少了。

常用的有三个类去实现Set接口（new的是这些类）：

1.HashSet类：实际上，HashSet集合在new的时候，底层实际是new了一个HashSet集合。HashSet集合中存储元素，实际上是存储HashMap集合中了。

Collection集合的方法：

存放在一个集合里面的类型，一定要重写equals方法

（contains、remove）

• contains底层调用的是equals方法

Collection c = new ArratList（）；
User s1 = new User("jack");
User s2 = new User("jack");
System.out.prntln( c.contains（s2）); //如果要比较的是内容，就要重写equals。不然比较的是内存地址

public void User(){
private String name;
public User(){}
public User(String name){
this.name = name;
}
}

//重写equals
public boolean equals(object o){
if(o == null || !(o instanceof User) ){       return false;
}
if(o == this){ 
return true;
}
User u = (User)o;//强转为User
return u.name.equals(this.name);
}

List集合的特有且常用的方法：

//创建集合
List mylist = new ArrayList();
//获取迭代器
Iterator it =mylist.iterator();
//常用方法
mylist.get();//根据下标获取元素
mylist.Indexof();//获取指定对象第一次出现的索引
mylist.lastIndexof();//获取指定对象最后一次出现的索引

2、一个是以键(key)值（value）对存储元素：

以键值对的方式存储元素，这一类集合的超级父接口：java.util.Map；

Map集合：

1.和Collection集合没有关系

2.以key和value的这种键值对的方式存储元素

3.key和value存储的都是java对象的内存地址

4.所有Map集合的key特点：无序不可重复

Map集合下实现类之一HashMap，

Map集合下实现类之一Hashtable

Map集合子接口SoetedMap的实现类之一TreeMap

总结：

Collection集合：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TSCho3Ei-1586702412990)(F:\学习笔记集合\Java学习笔记\图片\Collection.png)]

Map集合：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xiVZOxdZ-1586702412993)(F:\学习笔记集合\Java学习笔记\图片\Map.png)]

总结：

ArrayList：

public static void main(String[] args) {
ArrayList<String> mylist = new ArrayList<>();
//save
mylist.add("baba");
mylist.add("yeye");
//throw
String s = mylist.get(0);
String s1 = mylist.get(1);
System.out.println(s);
System.out.println(s1);
//遍历1:for循环
for (int i=0 ; i < mylist.size();i++){

System.out.println(mylist.get(i));
}
//方法二：迭代器
Iterator<String> it = mylist.iterator();
while(it.hasNext()){
String next = it.next();
System.out.println(next);
}
//way3:use Foreach

for (String s2 :
    mylist) {
System.out.println(s2);

}
}

LinkedList:

public static void main(String[] args) {
LinkedList<String> mylist = new LinkedList<>();
//save
mylist.add("baba");
mylist.add("yeye");
//throw
String s = mylist.get(0);
String s1 = mylist.get(1);
System.out.println(s);
System.out.println(s1);
//遍历1:for循环
for (int i=0 ; i < mylist.size();i++){

System.out.println(mylist.get(i));
}
//方法二：迭代器
Iterator<String> it = mylist.iterator();
while(it.hasNext()){
String next = it.next();
System.out.println(next);
}
//way3:use Foreach

for (String s2 :
mylist) {
System.out.println(s2);
}
}

HashSet:

/**
 * HashSet
 * 特点：无序不可重复
 * 需要掌握：
 * 1.创建集合对象
 * 2.添加元素
 * 3.获取元素
 * 4.遍历
 * 5.使用一个自定义的类型来遍历
 */
public static void main(String[] args) {
HashSet<String> myset = new HashSet<>();
myset.add("baba");
myset.add("yeye");
//way one
for (String s : myset) {
System.out.println(s);
}

//way two:
Iterator<String> it = myset.iterator();
while (it.hasNext()) {
String next = it.next();
System.out.println(next);


}

//使用自定义的类型来遍历
HashSet<Student1> mys = new HashSet<>();
mys.add(new Student1(01, "wzk"));
mys.add(new Student1(02, "wjj"));

//use the stronger foreach
for (Student1 s :
mys
) {
System.out.println(s);
}

System.out.println("==============================");
//way two:you should use the while when you try use iterator
Iterator<Student1> iterator = mys.iterator();
while (iterator.hasNext()) {
Student1 next = iterator.next();
System.out.println(next);

}
}
}
class Student1 {
private int no;
private String name;

public Student1() {
}

public Student1(int no, String name) {
this.no = no;
this.name = name;
}

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

//重写之后比较的才是对象，不是引用地址


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

@Override
public int hashCode() {
return Objects.hash(no, name);
}

TreeSet:

/**
 * TreeSet
 * 特点：无序不可重复,但是存进去的元素会自动排序
 * 需要掌握：
 * 1.创建集合对象
 * 2.添加元素
 * 3.获取元素
 * 4.遍历
 * 5.测试存储的元素是自定义的
 * 6.通过比较器来的设置，来将自定义元素的排序进行设置
 *
 *
 */


public static void main(String[] args) {
TreeSet<Integer> mytree = new TreeSet<>();
mytree.add(1);
mytree.add(5);
mytree.add(6);
mytree.add(2);
mytree.add(10);

//way one ：
for (Integer s :
mytree) {
System.out.println(s);
}

//way two:
Iterator<Integer> it = mytree.iterator();
while (it.hasNext()){
Integer next = it.next();
System.out.println(next);


TreeSet<A> ta = new TreeSet<>();
ta.add( new A(100));
ta.add( new A(10));
ta.add( new A(1010));
ta.add( new A(12));

//way one ：
for (A  a:
    ta) {
System.out.println(a);
}
System.out.println("================");
//way two:
Iterator<A> iterator = ta.iterator();
while (iterator.hasNext()){
A next1 = iterator.next();
System.out.println(next1);


}

}





}

//编写比较器
static class A implements Comparable<A> {
int i;

public A(int i) {
this.i = i;
}

@Override
public String toString() {
return "A{" +
"i=" + i +
'}';
}
//继承了这个接口就必须实现他的抽象方法
@Override
public int compareTo(A o) {
return this.i- o.i;
}
}

Properties:

public static void main(String[] args) {
Properties pro = new Properties();
pro.setProperty("username","root");
pro.setProperty("password","password");

pro.getProperty("username");
pro.getProperty("password");

}

HashMap:

public static void main(String[] args) {
HashMap<Integer,String> hmap = new HashMap<>();
hmap.put(1,"wzk");
hmap.put(2,"wzs");
hmap.put(3,"wzd");
hmap.put(4,"wzf");
hmap.put(5,"wzg");
hmap.put(6,"wzb");
hmap.put(7,"wzn");

System.out.println(hmap.get(1));
System.out.println("========================");


//一、通过转换成set的方式获，将set的元素存放到map的key键中
Set<Integer> set = hmap.keySet();

//die dai qi
Iterator<Integer> iterator = set.iterator();
while(iterator.hasNext()){
Integer next = iterator.next();
System.out.println(next+"="+hmap.get(next));
}
//foreach
System.out.println("=====================");
for (Integer i :
set) {
System.out.println(i+"="+hmap.get(i));
}
System.out.println("===================================");
//二、通过 entrySet,通过这种方法，获取的m元素，具有键值对，可以通过m.getkey和m.getvalue来获取
Set<Map.Entry<Integer, String>> entries = hmap.entrySet();

for (Map.Entry<Integer, String> m :
entries) {
System.out.println(m.getKey()+"="+m.getValue());
}


}

TreeMap:

和TreeSet类似

="+hmap.get(next));
}
//foreach
System.out.println("=");
for (Integer i :
set) {
System.out.println(i+"="+hmap.get(i));
}
System.out.println("===============");
//二、通过 entrySet,通过这种方法，获取的m元素，具有键值对，可以通过m.getkey和m.getvalue来获取
Set<Map.Entry<Integer, String>> entries = hmap.entrySet();

for (Map.Entry<Integer, String> m :
entries) {
System.out.println(m.getKey()+"="+m.getValue());
}

}

#### TreeMap:

和TreeSet类似