java 集合类之间的继承关系#

Java的集合类主要由两个接口派生而出：Collection和Map,Collection和Map是Java集合框架的根接口。代表了两种不同的数据结构：集合和映射表。

图中，ArrayList,HashSet,LinkedList,TreeSet是我们经常会有用到的已实现的集合类。

Map实现类用于保存具有映射关系的数据。Map保存的每项数据都是key-value对，也就是由key和value两个值组成。Map里的key是不可重复的，key用户标识集合里的每项数据。

迭代器的作用#

由于Java中数据容器众多，而对数据容器的操作在很多时候都具有极大的共性，于是Java采用了迭代器为各种容器提供公共的操作接口

解耦效果：使用迭代器iterator可以使对容器的遍历操作完全与其底层相隔离，可以到达极好的解耦效果

iterator方法返回一个实现了Iterator接口的对象，作用是依次访问集合中的元素，Iterator接口包含3个方法：

1
boolean hasNext();  # 如果任有元素可以迭代，则返回true.
2
E next();        # 返回迭代的下一个元素
3
void remove();     # 从迭代器指向的collection中移除迭代器返回的最后一个元素(可选操作)

通过多次调用next()方法可遍历集合中的所有元素，需要注意的是需要在调用next()之前调用hasNext()方法，并在hasNext()返回true的时候才可以调用next().

1
public static void main(String[] args)
2
{
3
        List<String> list=new ArrayList<>();
4
        list.add("C++");
5
        list.add("python");
6
        list.add("java");
7
        for(Iterator<String> it=list.iterator();it.hasNext();)
8
        {
9
            String item = it.next();
10
            if("python".equals(item)){
11
              // list.remove(item);  // 翻车写法：下次 it.next() 会抛 ConcurrentModificationException
12
              it.remove();           // 正确写法
13
            }
14
        }
15
    }

遍历集合时删除特定元素一定要用Iterator的remove,别用集合自带的remove。会报错：

java.util.ConcurrentModificationException
在集合内部维护一个字段modCount用于记录集合被修改的次数，每当集合内部结构发生变化(add,remove，set)时，modCount+1。　　
在迭代器内部也维护一个字段expectedModCount，同样记录当前集合修改的次数，初始化为集合的modCount值。调用Iterator遍历时，每次next()都会检查modCount和expectedModCount是否相等，不等就抛出并发修改异常java.util.ConcurrentModificationException。最典型的场景恰恰是单线程——自己在for循环里调了list.remove()，集合的modCount变了而迭代器的expectedModCount没变。多线程下别的线程改集合同样会触发。注意它是fail-fast机制，只保证尽快发现问题，不保证一定能检测到。

集合的排序#

java集合的工具类Collections中提供了两种排序的方法,分别是:

1. Collections.sort(List list)
2. Collections.sort(List list,Comparator c)

第一种称为自然排序,参与排序的对象需实现comparable接口,缺点会入侵代码

第二种叫定制排序,或自定义排序,需编写匿名内部类,先new一个Comparator接口的比较器对象,优点不用修改排序对象代码，例子：

1
Collections.sort(ordered, new Comparator<Student>() {
2
      @Override
3
      public int compare(Student t1, Student t2) {
4
        return (int) (t1.getOrder() - t2.getOrder());
5
      }
6
    });

java8函数式排序

1
//根据学生身高排序
2
list.sort(Comparator.comparing(Student::getHeight).reversed())

泛型#

泛型类

1
class Demo<T>{
2
    public T fun(T t){
3
        return t;
4
    }
5
    public <T> T fun2(T t){
6
        return t;
7
    }
8
}

泛型类的方法和泛型方法区别：

• 一个是在实例化对象才确认下来的 【泛型类的方法】
• 一个是在方法调用时确认下来的 【泛型方法】

1
// 虽然方法中使用了泛型，但这并不是泛型方法
2
public T fun(T t){           // 可以接收任意类型的数据
3
    return t;                // 直接把参数返回
4
}

1
// 这个<T>修饰的方法才是真的泛型方法
2
public static <T> T fun2(T t){          // 可以接收任意类型的数据
3
    return t;                           // 直接把参数返回
4
}

spring注解、事务传播机制#

1
public class WePageManagerServiceImpl implements WePageManagerService {
2

3
    @Override
4
    public void pagePublish(MysRequest request) {
5
        PublishHandler(request);
6
    }
7

8
    @Transactional(rollbackFor = Exception.class)
9
    protected ProcResult<String> PublishHandler(WePagePublishRequest request) {
10
        //多表dao操作......
11
    }
12
}

1
public class WePageManagerServiceImpl implements WePageManagerService {
2

3
    @Autowired
4
    private MyTransaction myTransaction;
5

6
    @Override
7
    public void pagePublish(MysRequest request) {
8
       myTransaction.pagePublishHandler(request);
9
    }
10
}
11

12
@Service
13
@Transactional(rollbackFor = Throwable.class)
14
public class MyTransactionImpl implements MyTransaction{
15
    protected ProcResult<String> pagePublishHandler(WePagePublishRequest request) {
16
        //多表dao操作......
17
    }
18
}