package cn.ekgc.javasenior.day20210621;
import java.util.ArrayList;
public class ArrayListDemo01 {
public static void main(String[] args) {
/*
* 1、ArrayList 是 List 接口的常用实现类,是使用频率最高的实现类。
* 2、ArrayList 的底层代码就是使用数组来实现的。
* 3、ArrayList 底层结构特征:
* (1)ArrayList 底层就是使用了一个 Object[] 进行存储相应的数据。
* (2)当创建一个 ArrayList 之后,那么那个 Object[] 的长度为 0;
* 4、由于 ArrayList 底层使用了 Object[],那么其特征就是:
* 查找速度较快,但是插入和删除速度较慢。
*/
// 创建一个 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<String> 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);
}
/*
* 1、相同点:无论是普通的 for 循环,还是增强型 for 循环,其目的都是在于遍历集合或者是数组;
* 2、不同点:
* (1)普通 for 循环有一个明确的 i 作为集合或者是数组的下标,
* (2)对于增强型 for 循环则不在出现这个下标,整个通过下标获得元素的过程在其内部自行完成取值。
* 3、如果只是单纯的循环遍历集合或者是数组,那么建议使用增强型 for 循环,
* 如果需要用到下标,那么建议使用普通的 for 循环。
*/
}
}
package cn.ekgc.javasenior.day20210621;
import java.util.LinkedList;
public class LinkedListDemo01 {
public static void main(String[] args) {
/*
* 1、由于 ArrayList 受到其底层数组的限制,查询效率较高,但是插入和删除效率较低,
* 当遇到需要进行频繁插入和删除的时候,可以使用 LinkedList 来完成。
* 2、LinkedList 底层使用双向链表,该结构特征将任意的一个元素分为三段,
* 第一段存储上一个元素的地址,第三段存储下一个元素的地址,而第二段用于存储该元素的值,
* 这样的结构好处就是,不需要所有的元素存储在连续的空间中。
* 3、其结构特征如下:
* (1)由于采用了双向链表,那么任意的一个元素都知道其上一个元素和下一个元素的位置,
* 那么在存储空间上,就不在需要是连续的。
* (2)在执行插入和删除时,只需要移动相关元素即可,而不需要其移动其他元素。效率极高。
* (3)由于存储的元素不在连续空间中,就导致在查找元素时,效率较低。
*/
// 创建 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<String> arrayList = new ArrayList<String>();
// 由于 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) {
/*
* 1、Set 集合在存储元素时,虽然是 Collection 的一个子接口,
* 但是其存储的元素并不是按照顺序进行存放,而是在内存中根据该元素的相关信息,
* 计算出该元素一个比较合适的存储位置,然后将该元素进行存储。
* 由于其存储的特征,就会导致有些元素在计算位置时,就会得到同一位置。
* 就会出现用后面的元素将前面的元素进行替换。导致在 Set 集合中就不会出现重复的元素。
* 2、Set 集合最大的特征就是无序不重复。
* 3、常用的 Set 集合就是 HashSet
*/
// 创建 HashSet 对象
HashSet<String> hashSet = new HashSet<String>();
// 要想向 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<String> 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) {
/*
* 通常在生活中,都会有通过编号来查找某个值的过程,那么编号和这个值通常是成对出现的,
* 那么为了能够表示这种成对出现的数据,那么 Java 提供了 Map 集合来进行表示。
* 1、Map 集合在存储数据的时候,需要数据以 key-value 这样的形式成对出现,
* 往往通过 key 来查找其对应的 value 值。
* 2、Map 集合在存储 key 的时候,采取了和 Set 集合一致的策略,
* 也就是根据 key 的特征在 Map 集合中查询出合适位置进行存储,
* 那么就导致 Map 集合中 key 无序不重复。由于在获得 value 时是通过 key 来完成,
* 那么 key 不重复也就导致了 value 不重复。
*/
// 创建 HashMap 对象
HashMap<String, String> hashMap = new HashMap<String, String>();
// 要想获得此时 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<String> 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("美利坚合众国"));
}
}