java总结

最新推荐文章于 2023-03-23 07:33:10 发布

Chxgx

最新推荐文章于 2023-03-23 07:33:10 发布

阅读量60

点赞数

文章标签： java jvm servlet

本文链接：https://blog.csdn.net/Chxgx/article/details/126651706

版权

集合

iterator迭代器

public interface Iterator {

boolean hasNext(); 判断是否有后续元素
E next(); 指针向后移动，同时返回指向的数据
default void remove() { 删除指针所指向的元素
throw new UnsupportedOperationException("remove");
}
使用lambda表达式的方式遍历所有元素
Lock接口
java中提供了两种不同的方式加锁，synchronized和juc包下的Lock接口。
sychronized可重入、不可中断、非公平;Lock可重入、可中断、非公平和公平;
Lock是java 1.5中引入的线程同步工具，它主要用于多线程下共享资源的控制。
- 需要用户主动释放锁
- 可中断，设置超时中断
- 默认也是非公平锁，可以设置成公平锁
- 锁绑定多个condition用来精确唤醒
常见方法：
void lock();尝试获取锁，获取成功则返回，否则阻塞当前线程
void lockInterruptibly() throws InterruptedException;尝试获取锁，线程在
成功获取锁之前被中断，则放弃获取锁，抛出异常
boolean tryLock();尝试获取锁，获取锁成功则返回true，否则返回false
boolean tryLock(long time, TimeUnit unit)尝试获取锁，若在规定时间内获取到
锁，则返回true，否则返回false，未获取锁之前被中断，则抛出异常
void unlock();释放锁，一般需要使用try/finally结构保证锁的释放
Lock和synchronized的区别:
- Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的
语言实现
- synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象
发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁(所以建议使用的
try/finally结构)，则很可能造成死锁现象，因此使用Lock时需要在finally块中
释放锁
- Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized
时，等待的线程会一直等待下去，不能够响应中断
- 通过Lock可以知道有没有成功获取锁，而synchronized却无法办到
Thread类中提供了一个静态方法，可以判断boolean holdsLock(Object obj)
- Lock可以提高多个线程进行读操作的效率。
在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈
时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在
具体使用时要根据适当情况选择。
Collection集合的特征：
*            无序允许重复
*
*        常见方法：
*            int size();获取集合中的元素个数
*            boolean contains(Object o) 判断集合中是否有指定的对象，有true没有false。
*            元素相等是依赖于equals方法实现的
*            Object[] toArray();将集合转换为Object类型的数组
*            <T> T[] toArray(T[] a);
*                String[] arrs=cols.toArray(new String[] {});
*            boolean add(E e);向集合中新增元素，成功true否则false
*            boolean remove(Object o);删除指定的元素o，相等判断使用equals
*            void clear(); 清空集合中的所有元素
    List接口
*        List集合的特征：
*            有序【有下标序号】   允许重复
*
*        public interface List<E> extends Collection<E>
*
*        特殊的方法就是引入序号
*            E get(int index);按照索引序号获取指定位置上的元素，需要不能越界
*            E set(int index, E element);修改指定位置上的元素，覆盖
*            void add(int index, E element);向指定位置上添加元素，原始数据后移
*            E remove(int index);删除指定位置上的元素，并返回被删除的元素，原始位置上的元素前移
*                有可能产生二义性的用法
*                    List<Integer> list=...;
*                    list.remove(3); 调用的是remove(int)方法，不是指定元素删除，而是指定位置删除
*                    list.remove(Integer.valueOf(3)); 删除指定元素，不是序号
*
*                Random r=new Random();
               for(int i=0;i<52;i++) {
                   int kk=list.remove(r.nextInt(list.size()));
                   System.out.println(kk);
               }

           int indexOf(Object o);从前向后查找第一次出现o的下标位置，如果查不到则返-1
           int lastIndexOf(Object o);从后向前查找


*
*            default void sort(Comparator<? super E> c) { 参数是自定义的比较器
*                Object[] a = this.toArray();
*                 Arrays.sort(a, (Comparator) c); 利用Arrays工具类实现排序
               ListIterator<E> i = this.listIterator();
               for (Object e : a) {
                   i.next();
                   i.set((E) e);   //修改集合中原始的数据
               }
           }
*
*                写法1：使用匿名内部类
*                list.sort(new Comparator<Number>() {
                   public int compare(Number o1, Number o2) {
                       return o1.intValue()-o2.intValue();
                   }
               });

               写法2：使用lambda表达式
               list.sort((o1,o2)->{
                   return o1.compareTo(o2);
               });
    Set接口
*        Set集合的特征：
*        无序【没有下标序号】不允许重复
*      Set接口没有新方法
*      Set接口的实现类：
*      HashSet底层实现为HashMap哈希表
*      LinkedHashSet底层实现为LinkedHashMap,在哈希表的基础上添加一个链表，记录添加元素的顺序
*      TreeSet底层实现为TreeMap红黑树
*