package cn.ekgc.javasenior.day20210621;
import java.util.ArrayList;
public class ArrayListDemo01 {
public static void main(String[] args) {
// 创建一个 ArrayList 对象
ArrayList arrayList = new ArrayList();
// 要想获得 ArrayList 中已经存储了多少个元素的值，可以使用 size();
int size = arrayList.size();
System.out.println("此时 ArrayList 中所存储的元素个数是：" + size);
// 如果要将某个数据存储到 ArrayList 中，可以调用 ArrayList 的 add()
// 在使用 add() 添加元素时，可以不用关心此时数组的长度，ArrayList 会自动对 Object[] 进行维护
arrayList.add("Hello");
arrayList.add("World");
arrayList.add(123);
arrayList.add(98.5);
arrayList.add("World");
arrayList.add(true);
// 在完成元素的添加之后，查看此时 ArrayList 的元素个数
System.out.println("经过元素的添加之后，此时 ArrayList 的元素个数是：" + arrayList.size());
// 要想从 ArrayList 中获得某个元素，可以使用该元素的下标，借助于 get() 来获得
// 获得下标为 2 的元素的值
int num = (int) arrayList.get(2);
System.out.println("下标为 2 的元素的值是：" + num);
// 如果需要将 ArrayList 中某个元素的值从数组中删除，可以借助于下标通过 remove() 实现
arrayList.remove(3);
System.out.println("将下标为 3 的元素的值移除后，数组的长度是：" + arrayList.size());
// 要想获得某个元素在 ArrayList 中的下标，可以使用 indexOf() 来获得
// 对于 indexOf() 在查找元素的时候，是按照从前往后进行查找，一旦找到，就返回该元素的下标
int index = arrayList.indexOf("World");
System.out.println("World 元素在 ArrayList 中的下标：" + index);
// 如果通过 indexOf() 未找到相应元素，那么会返回 -1 表示为找到。
System.out.println("world 元素在 ArrayList 中的下标：" + arrayList.indexOf("world"));
// 如果需要从后往前进行查找，那么可以使用 lastIndexOf() 来实现
System.out.println("使用 lastIndexOf() 从后往前查找元素的下标：" + arrayList.lastIndexOf("World"));
// 如果要确定在 ArrayList 中是否存在某个元素，可以通过 contains() 来确定
System.out.println("ArrayList 中是否存在元素 World：" + arrayList.contains("World"));
}
}
package cn.ekgc.javasenior.day20210622;
import java.util.Arrays;
import java.util.List;
public class ForEachDemo {
public static void main(String[] args) {
// 对于 ArrayList 来说，其本质上就是一个数组，那么对于任意的一个数组，都能够变为 ArrayList
// 创建一个 String[]
String[] cities = {"渭南", "西安", "咸阳", "宝鸡"};
// 要想将数组变为 ArrayList，则需要使用到 java.util.Arrays 的 asList() 实现
List cityList = Arrays.asList(cities);
// 使用 for 循环遍历 List 集合
for (int i = 0; i < cityList.size(); i++) {
// 将 i 作为下标，借助于 List 集合的 get() 获取当前元素
String city = cityList.get(i);
System.out.println(city);
}
// 在 JDK 5 就诞生了增强型 for 循环结构
for (String city : cityList) {
System.out.println("使用增强型 for 循环：" + city);
}
}
}
package cn.ekgc.javasenior.day20210621;
import java.util.linkedList;
public class linkedListDemo01 {
public static void main(String[] args) {
// 创建 linkedList 对象
linkedList linkedList = new linkedList();
// 由于 linkedList 和 ArrayList 都是 List 接口的实现类，导致两者有大量方法是相同的。
// 要获得 linkedList 中所存储元素的个数，那么通过 size()
System.out.println("此时 linkedList 中的元素个数是：" + linkedList.size());
// 通过 add() 向 linkedList 的末尾追加元素
linkedList.add("张涛");
linkedList.add("袁帅杰");
// 也可以通过下标向任意位置追加
linkedList.add(1, "李卓");
// linkedList 提供了向其头部和尾部进行追加元素
linkedList.addFirst("李静平");
linkedList.addLast("袁晓涛");
System.out.println("追加完毕后，元素的个数是：" + linkedList.size());
// 通过下标获得 linkedList 中所存储的元素
System.out.println("获得 linkedList 中下标为 0 的元素：" + linkedList.get(0));
System.out.println("获得 linkedList 中下标为 2 的元素：" + linkedList.get(2));
// 获得 linkedList 的第一个和最后一个元素
System.out.println("linkedList 中的第一个元素是：" + linkedList.getFirst());
System.out.println("linkedList 中的最后一个元素是：" + linkedList.getLast());
// 要想移除 linkedList 中的元素，则借助于下标，使用 remove 进行移除
// 移除下标为 3 的元素
linkedList.remove(3);
// 移除第一个和最后一个元素
linkedList.removeFirst();
linkedList.removeLast();
System.out.println(linkedList);
}
}
package cn.ekgc.javasenior.day20210621;
import java.util.ArrayList;
public class LoopDemo {
public static void main(String[] args) {
// 创建 ArrayList 对象
ArrayList arrayList = new ArrayList();
// 由于 ArrayList 底层使用了 Object[] 类型的数组，那么是可以放入任意数据类型的元素的
// 导致存储在 ArrayList 中的元素存在各种数据类型。那么在获取元素的时候，就无法确定该元素的数据类型。
// 因此对于集合中所存储的元素并不是任意类型都可以，而是和数组一样，规定相应的数据类型时比较方便。
// 因此需要规定存储集合中的元素的数据类型，那么在 JDK 5 产生了泛型的这一概念。
// 泛型：形如 <数据类型> 来规范存入一个集合中的数据类型。
// 要求所有的集合在创建的时候，都必须增加泛型，以约定所存储的数据类型。
// 需要特别注意的是，泛型中的数据类型不能是基本数据类型。
// Java 不属于纯面向对象语言，因为 Java 存在 8 个基本数据类型。
// 所谓的纯面向对象语言，指的是所有的数据类型都能够通过 new 来创建其对象。
// Java 之所以要存在 8 个基本数据类型，原因在于这 8 个基本数据类型的值会经常使用，为了能够高效率的使用，
// 就将其直接存储到了栈内存，因此不需要进行 new 来创建，从而存储到堆内存中。
arrayList.add("张涛");
arrayList.add("李静平");
// arrayList.add(250);
// arrayList.add(true);
// arrayList.add(new Student());
// arrayList.add('男');
// 使用 for 循环遍历 ArrayList
for (int i = 0; i < arrayList.size(); i++) {
// 由于有了泛型的约定，那么从这个集合中所提取的每个元素的数据累心就是统一的，那么不在需要强制类型转换
String str = arrayList.get(i);
System.out.println(str);
}
}
}
package cn.ekgc.javasenior.day20210622;
import java.util.HashSet;
import java.util.Iterator;
public class SetDemo01 {
public static void main(String[] args) {
// 创建 HashSet 对象
HashSet hashSet = new HashSet();
// 要想向 HashSet 中存放元素，那么通过 add() 来实现
hashSet.add("张涛");
hashSet.add("李静平");
hashSet.add("李卓");
hashSet.add("党奥");
// 通过 size() 获得此时 HashSet 中所拥有的元素数量
System.out.println("此时 HashSet 中所拥有的元素数量是：" + hashSet.size());
// 向 HashSet 中增加相同的元素
hashSet.add("张涛");
hashSet.add("李静平");
System.out.println("经过添加相同元素后，HashSet 的元素个数是：" + hashSet.size());
// 要想删除一个元素，通过 remove 来进行删除
// 对于 List 集合来说，在移除元素时，是通过下标进行的，
// 由于 Set 集合时无序的，那么就不存在下标这个概念，那么就只能通过元素本身进行删除
hashSet.remove("党奥");
System.out.println("移除一个元素之后，HashSet 的元素个数是：" + hashSet.size());
// 通过 contains 来确定是否包含该元素
System.out.println("HashSet 中是否包含 李卓123：" + hashSet.contains("李卓123"));
// 要想获得 Set 集合中的元素，是无法通过下标获得的，只能够进行循环遍历，判断是否是需要的元素
// 如果使用普通的 for 循环，是无法办到的，因为普通的 for 循环本质上还是借助于下标获得元素，
// 因为为了能够使用到 for 循环遍历 Set 集合，于是在 JDK 5 推出了增强型 for 循环，也成为了 for each 循环
for (String name : hashSet) {
System.out.println("使用增强型 for 循环循环 HashSet：" + name);
}
// 对于循环集合，提供了使用迭代器 Iterator 的方式来进行。
// 通常可以使用 Iterator 来迭代遍历 Set 集合
// 调用 Set 集合的 iterator() 将 Set 集合的所有元素变为一个 Iterator 对象
Iterator iterator = hashSet.iterator();
// 通过 Iterator 对象的 hasNext() 判断此时是否还有元素
// 由于元素的个数是无法确定的，因此使用 while 循环
while (iterator.hasNext()) {
// 当 iterator 的 hasNext() 判断为 true 的时候，则说明迭代器中还有元素
// 借助于 Iterator 的 next() 将该元素取出进行使用
String name = iterator.next();
System.out.println("使用迭代器的方式获得元素：" + name);
}
}
}
package cn.ekgc.javasenior.day20210622;
import java.util.HashMap;
import java.util.Set;
public class HashMapDemo01 {
public static void main(String[] args) {
// 创建 HashMap 对象
HashMap hashMap = new HashMap();
// 要想获得此时 HashMap 中的 key-value 的个数，通过 size() 能够获得
System.out.println("此时 HashMap 中的 key-value 组合个数：" + hashMap.size());
// 通过 put(key, value) 来向 HashMap 中存储 key-value 组合
hashMap.put("PRC", "中华人民共和国");
hashMap.put("USA", "美利坚合众国");
hashMap.put("RU", "俄罗斯联邦");
hashMap.put("RF", "法兰西共和国");
hashMap.put("UK", "大不列颠及北爱尔兰联合王国");
System.out.println("经过 put() 存放元素之后，此时 HashMap 中的值：" + hashMap.size());
// 向 HashMap 中存储一个 key 相同的组合
hashMap.put("USA", "灯塔之国");
System.out.println("在存放了相同 key 的组合之后，此时 HashMap 中的值：" + hashMap.size());
// 要想获得存储在 HashMap 中的 value，则需要通过 key 来获得
String usa = hashMap.get("USA");
System.out.println("USA - " + usa);
// 要想移除某个 key-value 组合，那么借助于 key 来实现
hashMap.remove("RF");
System.out.println("移除元素之后，HashMap 中的值的个数：" + hashMap.size());
// 通过 key = RF 来获得相应的元素
// 如果 Map 没有对应的 key，那么通过这个 key 所获得的 value 的值是 null。
System.out.println("RF - " + hashMap.get("RF"));
// 循环遍历 Map 集合中的每个 key-value 组合。
// 对于循环遍历 Map 集合，有以下两种思路：
// 1、由于 Map 集合中的 value 是通过 key 来获得的，如果能够循环遍历 Map 集合的 key
// 那么就可以借助于 key 来获取每一个 value
// 对于 Map 集合 key，是可以单独形成一个 Set 集合的。
Set keySet = hashMap.keySet();
// 对于变成 Set 集合的 key 来说，就可以使用增强型 for 循环来实现
for (String key : keySet) {
// 获得 key 之后，就可以借助于 Map 的 get 来获取对应的 value
String value = hashMap.get(key);
System.out.println(key + " : " + value);
}
// 要想判断 HashMap 中是否存在某个 key，可以通过 containsKey 来判断
System.out.println("HashMap 是否存在 key = RF：" + hashMap.containsKey("RF"));
// 要想直接判断是否存在 value，则通过 containsValue
System.out.println("HashMap 是否存在 value = 美利坚合众国：" + hashMap.containsValue("美利坚合众国"));
}
}
