目录
List
特点：有序有下标，数据可重复
有序是指存入取出一致
List提供的方法
1.增
void add(int index,E element)
作用：将元素添加到List的指定位置
参数：
index:插入的位置
elsement:添加的元素
List<String> a1=new ArrayList<String>();//转为其子类用用
a1.add("甲");
a1.add("乙");
a1.add("丙");
a1.add("丁");
System.out.println(a1);
a1.add(2, "test");//也是从0开始
System.out.println(a1); 
boolean addAll(int index,Collection<E> c)
作用：将一个集合的数据添加到当前集合指定位置
参数：
intdex：插入的位置
c：添加的集合
List<String> a2=new ArrayList<String>();
a2.add("戊");
a2.add("己");
a2.add("庚");
System.out.println(a2);
a1.addAll(3,a2);//3为传入的位置，a2为传入的集合
System.out.println(a1);
2.删
E remoue(int index)
作用：(删除指定位置元素)
参数：
intdex：指定位置
返回值：被删除的元素
a1.remove(1);
System.out.println(a1);
String str=a1.remove(1);
System.out.println(a1);
删除指定下标的元素，返回值为被删除的元素
3.改
E set(int index,E element)
作用：修改指定位置元素
参数：
intdex：指定的位置
element：修改后的元素
返回值：修改前集合中该位置的元素
a1.set(1," 哈哈");
System.out.println(a1);
a1.set(3,"子" );
System.out.println(a1);
4.查
E get(int index)
作用：获取指定位置的元素
参数：intdex指定的位置
返回值：指定位置的元素
注意：取出元素后，该元素依旧在集合中存在
System.out.println(a1);
String str=a1.get(3);
System.out.println(str);
System.out.println(a1); 
int indexOf
作用：查询元素在该集合中的位置
参数： o 查询的元素
返回值：元素在集合中的位置
注意：如果查询元素在集合中不存在会返回-1
int c1=a1.indexOf("哈哈");
int c2=a1.indexOf("甲");
System.out.println(c1+" "+c2);
int lastIndexOf(Object o)
作用：查询元素在集合中最后一次出现的位置
参数： o 查询的元素
返回值：元素在集合中最后一次出现的位置
注意：如果查询元素在集合中不存在会返回-1
System.out.println(a1.lastIndexOf("甲"));
<> subList(int fromIndex,int toIndex)
作用：截取集合中的一段元素
参数：
fromIndex:开始位置
toIndex:结束位置
返回值:
截取的元素集合
注意:
1,截取的元素包含开始位置,不包含结束位置
2,不会影响原集合的数据
System.out.println(a1);
a1.subList(3, 5);
System.out.println(a1.subList(3, 5));
System.out.println(a1);
练习：三种遍历List的方式
for (String s : a1) {
System.out.println(s);
}
System.out.println("------");
for (int i = 0; i < a1.size(); i++) {
System.out.println(a1.get(i));
}
System.out.println("-------");
Iterator<String> intEt=a1.iterator();
while (intEt.hasNext()) {
String str1 = intEt.next() ;
}
foreach
自带查找
迭代器
简单的数据结构概括
栈：先进先出
队列：先进先出
数组
特点：在内存中连续开辟一片空间，所以在寻找数组中数据时，计算机一次遍历内存即可，所以查询速度快
但是因为所有数据在同一片区域，此时如果插入或删除那么后续都会改动，所以增删速度慢。
链表：单链表：前一个数据存储着下一个数据的位置
双链表：前一个数据中存储上一个与下一个数据的位置
由于数据的物理地址是无序的，所以查找较慢，但是其修改存储的信息方便，所以增删 速度快
树：左叉，右叉，节点 以后再说
List常用子类：
ArrayList
数据结构：数组
特点：查询速度快，增删速度慢，线程不安全
时间：JDK1.2
LinkedList
数据结构：链表
特点：查询速度慢，增删速度快
时间：JDK1.2
vector
数据结构:数组
特点：查询速度快，增删速度慢，线程安全
时间：JDK1.0
注意：List的子类没有提供特有的方法
Set
Set没有提供特有的方法，所有的方法都来自Collection
特点：无序，无下标，元素不可重复
常用子类
HadhSet
数据结构：1.8以前是数组+链表
1.8及以后：数组+红黑树
注意：HashSet中数据前后顺序是根据存储的对象的hashcode值决定的
存储原理：
1.先调用对象的hashcode方法，取其值，使用该值与已存储对象的的hashcode值比较，如果不同则直接存储。
2.如果相同，则调用对象的equals方法与相同hashcode值的对象进行比较，如果不同则存储在集合中，如果相同则不存储
练习，去除重复元素
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof Student) {
Student s = (Student) obj;
if (s.name.equals(this.name)&&s.age==this.age&&s.naber==this.naber) {
return true;
}
}
return false;
}系统会自己调用equals方法，所以需要重写
LinkedHashSet
数据结构：1.8以前是数组+链表+链表
1.8及以后：数组+红黑树+链表
注意：LinkedHashSet中多出来的链表是用来记录存储顺序的，所以LinkedHashSet是有序的。
TreeSet
数据结构：红黑树
注意：
TreeSet存储数据时要么数据要有比较性，要么需要创建比较器
比较性：创建的方是实现Comparable接口，实现Comparable接口要重写compareTo的方法
public int compareTo(Student o) {
if(this.naber==o.naber) {
return this.naber-o.naber;//年龄一样用学号排序
}
if(this.age==o.age) {
return this.age-o.age;//用年龄排序
}
return 1;
}
重写compareTo方法
大于零左叉
小于零右叉比较器 在创建TreeSet对像时，传入实现了Comparator的接口对象
public class Test3 {
public static void main(String[] args) {
Student s1 = new Student(10010, "德玛", 18);
Student s2 = new Student(10008, "蛮王", 13);
Student s3 = new Student(10014, "寒冰", 12);
Student s4 = new Student(10053, "剑圣", 18);
Student s5 = new Student(10001, "狗熊", 28);
Student s6 = new Student(10021, "狗头", 48);
Student s7 = new Student(10013, "锤石", 29);
Student s8 = new Student(10015, "韩", 12);
Student s9 = new Student(10016, "并", 12);
TreeSet<Student>set=new TreeSet<Student>(new Comparator<Student>() {
public int compare (Student o1,Student o2) {
if(o1.getAge()!=o2.getAge()) {
return o1.getAge()-o2.getAge();
}
if(o1.getNaber()!=o2.getNaber()) {
return o1.getNaber()-o2.getNaber();
}
return 1;
}
});
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
set.add(s6);
set.add(s7);
set.add(s8);
set.add(s9);
System.out.println(set);
}
}练习
/**
* 1,将数组按照以下数据存储到ArrayList集合中
10,19,12,8,6,3,7,15
并使用冒泡排序对其进行排序
*
*
*
*
*/
ArrayList<Integer> a1=new ArrayList<Integer>();
a1.add(10);
a1.add(19);
a1.add(12);
a1.add(8);
a1.add(6);
a1.add(3);
a1.add(7);
a1.add(15);
int a=0;
int b=0;
System.out.println(a1);
for (int i = 0; i < a1.size(); i++) {
for (int j = 0; j < a1.size()-1; j++) {
if(a1.get(i)<a1.get(i+1)) {//判断相邻两元素大小
a=a1.get(i);
b=a1.get(i+1);
a1.set(i, b);//交换两元素
a1.set(i+1, a);//
}
}
}
System.out.println(a1);
/**
*
* 并使用选择排序对其进行排序.要求按照学号排序
*
*
*/
Student s1 = new Student(10010, "德玛", 18);
Student s2 = new Student(10008, "蛮王", 13);
Student s3 = new Student(10014, "寒冰", 12);
Student s4 = new Student(10053, "剑圣", 18);
Student s5 = new Student(10001, "狗熊", 28);
Student s6 = new Student(10021, "狗头", 48);
Student s7 = new Student(10013, "锤石", 29);
Student a = new Student();
Student b = new Student();
ArrayList<Student> a1=new ArrayList<Student>();
a1.add(s1);
a1.add(s2);
a1.add(s3);
a1.add(s4);
a1.add(s5);
a1.add(s6);
a1.add(s7);
System.out.println(a1);
for (int i = 0; i < a1.size(); i++) {
for (int j = 0; j < a1.size()-1; j++) {
if(a1.get(i).getNaber()>a1.get(j).getNaber()) {//比较学号值
a=a1.get(i);//
b=a1.get(j);
a1.set(i, b);
a1.set(j, a);
}
}
}
System.out.println(a1);
扫一扫
4663
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
