集合
List和Set的区别
1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
2. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 ，实现类有HashSet，TreeSet。
3. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 ，实现类有ArrayList，LinkedList，Vector，CopyOnWriteArrayList。
ArrayList与Vector的区别[Java] 纯文本查看 复制代码 import java.util.*;
public class ArrayListTest{
public static void main(String[] args) {
List<String> list=new ArrayList<String>();
list.add("Hello");
list.add("Java");
list.add("ArrayList");
//方法一：使用for或foreach遍历
for (String str : list) {
System.out.println(str);
}
//方法二：将集合转化为数组，然后进行for或foreach遍历
String[] strArray=new String[list.size()];
list.toArray(strArray);
for(int i=0;i<strArray.length;i++)
{
System.out.println(strArray[i]);
}
//方法三：使用迭代器器
Iterator<String> iterator=list.iterator();
while(iterator.hasNext())//判断下一个元素之后有值
{
System.out.println(iterator.next());
}
}
}
[AppleScript] 纯文本查看 复制代码 遍历Map
import java.util.*;
public class MapTest {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("1", "Hello");
map.put("2", "Java");
map.put("3", "Map");
//方法一：先通过Map.keySet遍历key，再通过key获取value值
for (String key : map.keySet()) {
System.out.println("key= "+ key + " and value= " + map.get(key));
}
//方法二：通过Map.entrySet使用iterator遍历键值对对象，再通过getKey()和getValue()获取key和value的值
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, String> entry = it.next();
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
//方法三：通过Map.entrySet遍历key和value
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
//方法四：通过Map.values()遍历所有的value，但不能遍历key
for (String value : map.values()) {
System.out.println("value= " + value);
}
}
}
[AppleScript] 纯文本查看 复制代码 遍历Set
import java.util.HashSet;
import java.util.Iterator;
public class SetTest {
public static void main(String[] args) {
HashSet<String> sets = new HashSet<>();
sets.add("h");
sets.add("e");
sets.add("l");
sets.add("l");//不可重复
sets.add("0");
//方法一：迭代遍历
for (Iterator<String> iterator = sets.iterator(); iterator.hasNext();){
System.out.println(iterator.next());
}
//输出结果：
/*
0
e
h
l
*/
//可以看出Set集合是不可重复（添加重复操作不会报错）且无序的
//方法二：foreach循环（没有普通for循环方法）
for (String value:sets) {
System.out.println(value);
}
}
}
两者都是基于索引，内部结构是数组
元素存取有序并都允许为null
都支持fail-fast机制
Vector是同步的，不会过载，而ArrayList不是，但ArrayList效率比Vector高，如果在迭代中对集合做修改可以使用CopyOnWriteArrayList
初始容量都为10，但ArrayList默认增长为原来的50%，而Vector默认增长为原来的一倍，并且可以设置
ArrayList更通用，可以使用Collections工具类获取同步列表和只读列表
适用场景分析：
1、Vector是线程同步的，所以它也是线程安全的，而ArrayList是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用ArrayList效率比较高。
2、如果集合中的元素的数目大于目前集合数组的长度时，在集合中使用数据量比较大的数据，用Vector有一定的优势。
ArrayList与LinkedList的区别
两者都是List接口的实现类
ArrayList是基于动态数组的数据结构，而LinkedList是基于链表的数据结构
对于随机访问get和set（查询操作），ArrayList要优于LinkedList，因为LinkedList要移动指针
对于增删操作（add和remove），LinkedList优于ArrayList
适用场景分析：
当需要对数据进行对此访问的情况下选用ArrayList，当需要对数据进行多次增加删除修改时采用LinkedList
HashMap和HashTable的区别
1. 都是基于hash表实现的，每个元素都是key-value对，内部都是通过单向链表解决冲突，容量都会自动增长
HashMap默认容量为16，每次扩容变为原来的2倍，HashTable初始容量为11，每次扩容变为原来的2倍加1
2. HashMap继承自AbstractMap类，HashTable继承自Dictionary类，
3. HashTable是同步的，适合多线程环境，而HashMap不是，但效率相对较高
4. HashMap允许key和value为null，而HashTable不允许
5. Hash值的使用不同，HashTable直接使用对象的hashcode值，而HashMap重新计算hash值
6. 在Java1.4中引入了HashMap的子类LinkedHashMap，若需要遍历顺序，可以从HashMap转向LinkedHashMap， 而HashTable的顺序是不可预知的
7. HashMap提供对key的Set进行遍历，因此它支持fail-fast机制，而HashTable提供对key的Enumeration进行遍历，不支持fail-fast
8. HashTable被认为是个遗留的类，如果在迭代的时候修改Map，可以使用ConcurrentHashMap（Java5出现）
9. HashTable产生于JDK1.1，而HashMap产生于JDK1.2
HashSet与TreeSet
HashSet不能保证元素的排列顺序，TreeSet是SortedSet接口的唯一实现类，可以确保集合元素处于排序状态
HashSet底层用的是哈希表，TreeSet采用的数据结构是红黑树
HashSet中元素可以是null，但只能有一个，TreeSet不允许放入null
适用场景分析：
HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet。
HashMap和ConcurrentHashMap的区别
1、HashMap不是线程安全的，而ConcurrentHashMap是线程安全的。
2、ConcurrentHashMap采用锁分段技术，将整个Hash桶进行了分段segment，也就是将这个大的数组分成了几个小的片段segment，而且每个小的片段segment上面都有锁存在，那么在插入元素的时候就需要先找到应该插入到哪一个片段segment，然后再在这个片段上面进行插入，而且这里还需要获取segment锁。
3、ConcurrentHashMap让锁的粒度更精细一些，并发性能更好。
Enumeration和Iterator的区别
1. Enumeration是JDK1.0出现的，只能读取集合的数据；
Iterator是JDK1.2出现的，用来替代Enumeration，增加了remove()方法，可以在迭代过程中移除元素
2. Iterator的方法名是标准化的
3. Iterator支持fail-fast机制，而Enumeration不支持
4. Enumeration的内存占用较少，效率比Iterator高，但Iterator更安全
Iterator和ListIterator的区别
1. ListIterator继承自Iterator接口，然后添加了一些额外的功能
2. 两者都有hasNext()和next()方法，可以实现顺序向后遍历，ListIterator还有hasPrevious()和previous()方法，可以实现逆序遍历
3. 都有remove()方法可以实现删除对象，ListIterator还有添加方法add()和修改方法set()，可以实现添加和修改对象，
Iterator的协议不能确保迭代的次序，所以没有提供add()方法
4. Iterator可以遍历Set和List集合，而ListIterator只能遍历List集合
5. ListIterator有nextIndex()和previousIndex()方法，可以定位当前的索引位置，Iterator没有此功能
*****************************************************************************************************
任何对象加入集合类后，自动转变为Object类型，所以在取出的时候，需要进行强制类型转换。
任何对象没有使用泛型之前会自动转换Object类型，使用泛型之后不用强制转换。
=================================================================
IO流;
字符流 该流只能处理字符，但处理字符速度很快
字节流 可以处理所有以bit为单位储存的文件，也就是说可以处理所有的文件，但是在处理字符上的速度不如字符流
从各种输入流到各种输出流
各个不同的类型中，输入流到输出流的套路基本都一样。
从FileOutputStream到FileIntputStream其实就是复制一个文件的过程，将文件读取到FileIntputStream中，后输出到FileOutputStream也就是相当于输出到了硬盘的文件中。
我们可以以两个桶为例，一个桶为FileIntputStream，另一个桶为FileOutputStream，如果要把一个桶里的水转移到另一个桶中，我们首先需要一个水瓢，一次次的舀水才能完成我们的需求。[Java] 纯文本查看 复制代码 public static void main(String[] args) throws IOException {
File fil1 = new File(“D:/111.pdf”);
File fil2 = new File(“D:/222.pdf”);
try (FileInputStream fi = new FileInputStream(fil1);
//一个叫输入流的桶，装满了一桶叫做D:/111.pdf文件的水
FileOutputStream fs = new FileOutputStream(fil2);
//一个叫输出流的空桶，但想装满叫做”D:/222.pdf”文件的水
) {
byte[] buf = new byte[521];
//叫做buf的水瓢
int len = -1;
//用来测量每次水瓢装了多少水
while((len = fi.read(buf)) != -1){
//一次次的用水瓢在输入流的桶里舀水，并用len测了舀了多少水，当len等于-1意味着水舀光了，该结束舀水了。
fs.write(buf, 0, len);
//一次次把水瓢里的水放到了输出流的桶里
}
fs.flush();
} catch (Exception e) {
}
}
| 
收藏
淘帖
踩
