一 ArrayList集合
ArrayList基本使用
-
- 有序 ： 存入的顺序和取出的顺序一致
-
- 可以存放重复的元素
-
- 底层是数组实现的 ： 查询和修改较快， 删除和添加相对较慢些
-
- 扩容：默认容量是10，每次扩容原长度的1.5倍【高效运算符 >>】
集合使用语法：
public class Test{
public static void main(String[] args) {
创建集合对象
ArrayList<泛型类型> 对象变量名 = new ArrayList<>();
1.添加元素
对象变量名 .add(Value);
2.插入元素
对象变量名.add(index , value);
3.删除元素
数据类型 变量名 = 对象变量名.remove（index）;
//按照指定内容删除 默认一次只能删除一个
数据类型 变量名 = 对象变量名.remove（value）;
4. 集合长度
System.out.println(对象名.size());
5.清空集合
list.clear();
6.. 通过索引来获取集合元素
数据类型 变量名 = 对象变量名.get（index）;
7. 根据索引来修改集合的值 update
数据类型 变量名 = 对象变量名.set（value）;
8. 截取一个子集合 .subList(fromIndex, toIndex)
List<范型类型> subList = list.subList(1,对象的.size()); // 新建一个子集合 采用左闭右开
9.了解 ： 可以将集合转成数组【掌握泛型：泛型在运行期就失效了，使用Object来表示】
Object[] 数组名 = 对象名.toArray();
10 合并集合数据、
ArrayList<泛型> 新集合名= new ArrayList<>();A
}
集合遍历
集合遍历
1. 使用基础for循环来获取集合数据(必会)
for (int i = 0; i < list.size(); i++) { // 使用索引
System.out.println(list.get(i));
}
2. 使用加强for循环来遍历（底层是使用迭代器实现的）
for(String str : list) { // 没有索引的使用
System.out.println(str);
}
3.使用迭代器Iterator来遍历
iterator.next() : 从迭代器中获取到当前元素并且将元素的索引向后移动一个位置
当迭代器中没有元素时，则会抛出 java.util.NoSuchElementException 没有元素异常
iterator.hasNext(); : 判断迭代器中是否存在下一个元素，存在就返回true ,不存在就返回false(解决上面遍历时异常)
Iterator<String> iterator = list.iterator(); // 将集合元素存放在迭代器对象中
while(iterator.hasNext()) { // 判断迭代器中是否存在下一个元素
System.out.println(iterator.next());
}
删除集合元素
删除集合元素
1.迭代器删除
private static void 迭代器删除(ArrayList<String> list) {
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()) {
String str = iterator.next();
if("a".equals(str)) {
iterator.remove(); // 使用迭代器自己删除
// list.remove(str); // 产生并发修改异常
}
}
System.out.println(list);
2. 能否使用加强for来删除呢？【不能】
// for (String str : list) {
// if("a".equals(str)) {
// list.remove(str);
// }
// }
/**
* 特殊异常： java.util.ConcurrentModificationException 并发修改异常
*/
}
3.普通for循环
private static void 普通for循环(ArrayList<String> list) {
//1. for循环实现
// for (int i = 0; i < list.size(); i++) {
// String str = list.get(i);
// if("a".equals(str)) {
// list.remove(i--); // 根据下表删除
// }
// }
// System.out.println(list);
for (int i = list.size()-1; i >=0; i--) {
String str = list.get(i);
if("a".equals(str)) {
list.remove(i); // 根据下表删除
}
}
System.out.println(list);
}
}
集合去重
public static void main(String [] args){
ArrayList<String > = new ArrayLisy<>();
list.add("a");
list.add("b");
list.add("d");
list.add("a");
list.add("c");
list.add("b");
ArrayList <String> newList = new ArrayList<>();
for(String str:list){
if(!newList.contains(str)){//判断集合中是否有这个元素 （contains）包含
newList.add(str);
}
System.out.println(newList);
}
}
比较器
内置比较器
Comparable : 内置比较器（类）用于类中 comparaTo是将比较器的规则重写
语法：
主类名 implemes Comparable <泛型>{
private 成员变量
无参构造{
}
有参构造{
}
get set方法{
}
// 内置比较器 的规则定义
public 数据类型 compareTo(Employee o){
compareTo
return 数据值
}
调用用法 Collections.sort(list);//调用时需要将类实现comparabale
}
外部比较器
Comparator : 外置比较器接口（外部）
package arraylist;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Test8 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(10);
list.add(2);
list.add(8);
list.add(1);
list.add(9);
list.add(4);
list.add(4);
/*
* 分析排序原理
* Comparator<T> : 外置比较器接口（外部）
* Comparable<T> : 内置比较器（类）
*/
// Integer 默认是按照升序排序的，我们能否去改变官方原有的排序规则变成降序呢？
// 解决方法 ： 使用自定义的外置比较器来覆盖已有的比较规则
Comparator<Integer> comparator = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
};
// Collections.sort(list); // 默认是升序，根据Integer原有的排序来实现
Collections.sort(list, comparator);
System.out.println(list);
}
}
调用
// 官方提供的快排序
Collections.sort(list); // 默认是升序
Collections.reverse(list); //反转集合元素
Collections.shuffle(list); // 随机打乱集合元素
LinkedList 链表集合
- LinkedList 双向链表结构 【单向链表，双端链表，双向链表，环形链表】
- 底层实现是通过Node（data,previous,next）节点, 实现了Deque双端队列
- JDK1.2官方提供的LinkedList在链表基础上做了查询优化，加了索引
- 特点 ：
优点 ：添加和删除速度较快
缺陷 ： 随着链表长度的增加，查询速度会降低
语法：
public class Test1 {
public static void main(String[] args) {
inkedLList<String> list = new LinkedList<>();
//1. 双向添加元素
list.addFirst("a");
list.addFirst("b");
list.addFirst("c");
list.addLast("A");
list.addLast("B");
list.add("C"); // 追加（等同于addLast）
System.out.println(list);
//2. 双向删除
String removeFirst = list.removeFirst();
System.out.println(list);
String removeLast = list.removeLast();
System.out.println(list);
//3. 常用方法
list.size(); // 求链表长度（链表中元素的个数）
list.isEmpty(); // 判断是否是空链表
System.out.println(list.contains("A")); // 判断链表中是否存在这个元素
// list.clear(); // 清空集合 [b, a, A, B]
// 浅拷贝 ： 只会拷贝对象地址
LinkedList<String> list2 = list;
// list2.removeFirst();
// 深拷贝(克隆) ：全新的对象
LinkedList<String> list3 = (LinkedList<String>) list.clone();
list3.removeFirst();
System.out.println(list);
//4. 优化后可以通过索引直接访问元素 list [b, a, A, B]
System.out.println(list.get(0));
list.indexOf("A");
list.lastIndexOf("A");
}
}
LinkedList删除
public class Test3{
public static void main(String[] args){
LinkedList<Character> list = new LinkedList<>();
list.add("a");
list.add("b");
//基础for循环
for (int i = 0 ; i <list.size ;i++){
if(list.get(i) == "a"){
list.remove(i--);
}
}
for (int i = list.size ; i >=0 ; i--){
if(list.get(i) == "a"){
list.remove(i);
}
}
Iterator<Character> itterator = list.iterator();
while (iterator.hasNext()){
Character ch = iterator .next();
if(ch == 'a'){
iterator.remove();
}
}
System.out.println(list);
}
}
LinkList调用
public class Test3{
public static void mian (Sytring[] args){
LinkedLiist<Integer>list = new LinkedList<>();
list.add('2');
list.add('3');
list.add('5');
Collections.sort(list);
Collections.shuffle(list);
system.out.println(list);
}
}
1114
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
