集合
List：数据是有顺序的（添加的先后顺序）的，数组是可以重复的
ArrayList：内部结构是数组，比较适合做高频率的查找遍历。线程异步的不安全
LinkList:双向链表 比较适合做高频率的新增和删除
Vector：和ArrayList几乎一摸一样，线程同步的安全
代码展示：
public static void main(String[] args) {
//List<String> list=new LinkedList<>();
LinkedList<String> list=new LinkedList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
//我们在创建对象的时候是多态
//父类对象指向子类引用
//我们创建出来的对象只能够调用父类和子类中都有的方法
list.addFirst("z");
//根据下标索引获取指定位置的元素
String z = list.get(list.indexOf("z"));
System.out.println(z);
System.out.println(list);
}
}面试题：ArrayList和LinkedList的区别
1.数据结构不同
ArrayList是Array(动态数组)的数据结构，LinkedList是Link(链表)双向链表的数据结构。
2.从线程安全性来讲：
ArrayList是线程不安全的，而LinkedList是线程安全的。
3.效率不同:
当随机访问List（get和set操作）时，ArrayList比LinkedList的效率更高
但是ArrayList对于数据查询非常快，但是插入与删除元素比较慢
LinkedList是恰好相反的，它的查询速度非常慢，但是插入与删除元素的速度非常快。
LinkedList：增删改快
ArrayList：查询快（有索引的存在
面试题 ：ArrayList和Vector的区别
1. 从线程安全性来讲
Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而Arraylist是线程异步，线程不安全，因此,ArrayList的性能比Vector好。
面试题：Set和List的区别
1.List有顺序，元素可以重复，顺序指的是添加的先后顺序
2.set无序，元素不可以重复，顺序指的是添加的先后顺序
*（Set集合其实是有顺序的，内部有一个专门排序的算法。）
所谓的无序不等于随机
所谓的无序指的是没有按照添加的先后顺序，其实内部是做了排序的。
set集合如何确保数据的不重复：
保证数据类型的类要重写hashCode和equals方法。
public static void main(String[] args) {
Set<Person> set=new HashSet<>();
set.add(new Person("sun",19) );
set.add(new Person("sun",19) );
set.add(new Person("sun",19) );
//Set集合所谓的不能重复，默认情况下比较的是地址'
System.out.println(set);
}
}
TreeSet：默认从小到大排序的
TreeSet的排序规则
要排序的对象的类必须实现Comparable接口
TreeSet使用红黑树结构进行保存，因此其内部是有序的，输出也是有序的．
public static void main(String[] args) {
Set<Integer> set=new TreeSet<>();
Set<Person> set1=new TreeSet<>();
set1.add(new Person("sun",11));
set1.add(new Person("李四",10));
set1.add(new Person("张三",12));
set.add(5);
set.add(2);
set.add(4);
set.add(7);
set.add(1);
System.out.println(set);
System.out.println(set1);
}
}LinkedHashSet：在添加数据的同时维护数据的添加顺序，效率要比HashSet略低一些
面试题：HashSet和LinkedHashSet有什么区别和联系？
联系： LinkedHashSet是HashSet的子类
区别： 当要操作大量的数据或是需要遍历集合所有的数据时使用LinkedHashSet会比HashSet要好一些。
LinkedHashSet：以元素插入的顺序来维护集合的链接表，允许以插入的顺序在集合中迭代
HashSet输出是和原来的添加的顺序是不一致的，因为其保存的位置是根据其哈希值来确定．
LinkedHashSet使用链表来保存，因此输出时和插入时的顺序是一致的．
public static void main(String[] args) {
LinkedHashSet<String> set=new LinkedHashSet<>();
set.add("1");
set.add("哈哈");
set.add("H");
set.add("2");
System.out.println(set);
}
}比较接口：
Comparable：接口：自然排序，排序规则是固定的
自然排序：如String类、包装类或自己写的类已经实现了Comparable接口，并重写了compareTo方法，那么直接调用Arrays.sort( ) 方法，就可以实现排序
像String、包装类等实现了Comparable接口，重写了compareTo( ) 方法，给出了比较两个对象大小的方式，方式是从小到大。
实现Comparable接口的对象列表（和数组），可以通过Collections.sort或Arrays.sort进行自动排序。
重写compareTo( ) 的规则：
① 如果当前对象this大于形参对象obj，则返回正整数；
② 如果当前对象this小于形参对象obj，则返回负整数；
③ 如果当前对象this等于形参对象obj，则返回 0；
Comparator：接口：临时排序
定制排序：不想使用已经定义好的排序方法，可以使用Arrays.sort(T[] a, Comparator<? super T> c )方法，创建匿名内部实现类，根据实际情况，临时性的自定义排序顺序，以实现精确控制
重写compare（Object o1 , Object o2）方法，比较o1和o2的大小
① 如果返回正整数，表示o1 > o2
② 如果返回负整数，表示o1 < o2
③ 如果返回 0 ，表示相等
public static void main(String[] args) {
List<Person> list = new ArrayList<>();
list.add(new Person("李四", 1100));
list.add(new Person("张岳", 1010));
list.add(new Person("刘海柱", 1020));
/* list.sort(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return 0;
}
});*/
list.sort((o1, o2) -> {
//临时排序
if (o1.getId() < o2.getId()) {
return -1;
}
if(o1.getId()==o2.getId()){
return 0;
}
return 1;
});
System.out.println(list);
}
}比较：
- Comparable接口的方式一旦确定，保证Comparable接口的实现类的对象在任何位置都可以调用Arrays.sort( )方法进行大小比较
- Comparator接口属于临时性的比较
面试题：Hashtable和HashMap的区别？
1、线程安全性
首先，HashMap是非synchronized的，而Hashtable是synchronized的。这说明Hashtable是线程安全的，而且多个线程可以共享一个Hashtable；
而HashMap如果没有正确的同步的话，是不能被多个线程所共享的。
由于Hashtable是线程安全的，也是synchronized的，所以在单线程环境下比HashMap要慢。如果你不需要同步且只需要单一线程的话，那么使用
HashMap性能要比Hashtable好一些。此时，HashMap是个不错的选择。
2、容纳数据
HashMap几乎可以等价于Hashtable，除了HashMap是非synchronized的，并可以接受null值（HashMap可以存在null的键值(key)和值(value),
但是Hashtable是不可以的)。
Set集合的遍历
public static void main(String[] args) {
Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(3);
set.add(4);
/*for (Integer integer : set) {
System.out.println(integer);
}*/
Iterator<Integer> iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
Map集合的遍历
public static void main(String[] args) {
Map<String,String> map=new HashMap<>();
map.put("sun","sss");
map.put("sun1","sss");
map.put("sun2","sss");
map.put("sun3","sss");
Set<String> keySet = map.keySet();
Collection<String> values = map.values();
//增强for循环
//Entry是HashMap的内部类
//每一组键值对就是一个Entry
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry.getKey()+"-->"+entry.getValue());
}
/* for (String s :ke) {
System.out.println(map.get(s));
};*/
}
}
List集合的遍历
public static void main(String[] args) {
List<String> list=new ArrayList<>();
list.add("1");
list.add("1");
list.add("1");
list.add("1");
/* for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
for (String s : list) {
System.out.println(s);
}*/
//3.迭代器遍历数组
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){//判断是否有下一个元素
System.out.println(iterator.next());//拿到下一个元素
//指针后移
}
}
}线程安全问题:
迭代器是依赖于集合而存在的，判断成功以后，集合中新增了元素，
迭代器不知道，所以就报错了
解决：
1.迭代器遍历元素，迭代器删除元素
2.普通for循环遍历，集合删除
在迭代中删除元素
public static void main(String[] args) {
List<String> names=new ArrayList<>();
names.add("tom");
names.add("lucy");
names.add("lucy");
names.add("lucy");
names.add("jerry");
/* for (int i = 0; i < names.size(); i++) {
if("lucy".equals(names.get(i))) {
names.remove(i);
//回调指针
i--;
}
}*/
//2.逆序遍历
/* for (int i = names.size()-1; i >=0 ; i--) {
if("lucy".equals(names.get(i))) {
names.remove(i);
}
}*/
/* for (String s :names) {
if("lucy".equals(s)) {
int i = names.indexOf(s);
System.out.println(i);
*//*names.remove(i);*//*
}
}*/
//3.使用迭代器
/* Iterator<String> iterator = names.iterator();while(iterator.hasNext( )) {
String s = iterator.next();
if(Objects.equals(s, b: "lucy" )){
iterator.remove();
}
}*/
System.out.println(names);
}
}
扫一扫
296
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
