这里面的部分概念参考了《Apress JavaI.O . NIO and NIO2》

Buffer

NIO的一些操作基础就是Buffer

Channels

它的具体作用是帮助 DMA 快速的从硬盘上获取和写入数据

在刚接触Java的时候经常听到的一句话便是在 Java 中，Exception 是可以捕获的，Error 是不可以捕获的。但是在随着学习的深入，会发现有些观点需要重新认识下了。
Throwable 这个类是自 JDK1.0 开始就存在于 Java 的语言之中。

Throwable

首先引用一段 Oracle 官方文档上对 Throwable 的介绍Java8 Thrwoable的介绍：

The Throwable class is the superclass of all errors and exceptions in the Java language. Only objects that are instances of this class (or one of its subclasses) are thrown by the Java Virtual Machine or can be thrown by the Java throw statement. Similarly, only this class or one of its subclasses can be the argument type in a catch clause. For the purposes of compile-time checking of exceptions, Throwable and any subclass of Throwable that is not also a subclass of either RuntimeException or Error are regarded as checked exceptions.
Instances of two subclasses, Error and Exception, are conventionally used to indicate that exceptional situations have occurred. Typically, these instances are freshly created in the context of the exceptional situation so as to include relevant information (such as stack trace data).
太长，省略大部分了……

简单翻译下就是，Throwable 是 Error 和 Exception 的父类，并且只能是 Error 和 Exception 的实例才可以通过 throw 语句或者 Java虚拟机 抛出异常。Exception 或者 Error 是在出错的情况下新创建的，从而将出错的信息和数据包含进去。
另外在这个文档中还提到了一点就是当低层方法向高层方法抛出异常的时候，如果抛出的异常是受检查的异常，则

首先简单介绍下TreeSet和TreeMap的两种排序：

• 自然排序
• 通过comparator排序

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  private static void compareWithCpmparator(){ TreeSet<String> treeSet =new TreeSet<>(); List<String> list =new ArrayList<>(); list.add("a"); list.add("d"); list.add("b"); treeSet.addAll(list); Iterator<String> iterator =treeSet.iterator(); while (iterator.hasNext()){ System.out.println(iterator.next()); } Comparator<String> comparator1 = (Comparator<String>) treeSet.comparator(); if (comparator1 == null){ System.out.println("comparator1是空"); }else { System.out.println("comparator1不是空"); } } public static void main(String[] args) { compareWithCpmparator(); }

  运行之后的结果如下:

  1 2 3 4

  a b d comparator1是空

  这段代码里面获取的comparator是空的，Debug一遍，发现这个方法其实调用的是NavigableMap里面的comparator

  1 2 3

  public Comparator<? super E> comparator() { return m.comparator(); }

  查看官网上对其的介绍：

  1 2 3 4

  Comparator<? super K> comparator() Returns the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys. Returns: the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys

  在调用这个方法的时候若是自然排序，那么会返回一个null。若是通过comparator进行排序的话当前集合采用的comparator。
  查看官网对reeSet的无参构造器的解释：

  /**

  • Constructs a new, empty tree set, sorted according to the
  • natural ordering of its elements. All elements inserted into
  • the set must implement the {@link Comparable} interface.
  • Furthermore, all such elements must be mutually
  • comparable: {@code e1.compareTo(e2)} must not throw a
  • {@code ClassCastException} for any elements {@code e1} and
  • {@code e2} in the set. If the user attempts to add an element
  • to the set that violates this constraint (for example, the user
  • attempts to add a string element to a set whose elements are
  • integers), the {@code add} call will throw a
  • {@code ClassCastException}.

在使用TreeSet的时候，插入的元素需要实现Comparable这个接口，而刚刚的元素是String，查看String的代码发现:

1

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {

确实实现了，再测试一个没有实现的元素：

在Java里面，List转为Array是调用的Java的一个Arrays.copyOf()这个方法，查看了下源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public Object[] toArray() {
        return Arrays.copyOf(this.elementData, this.size);
    }

 public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

 public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }


 public static Object newInstance(Class<?> componentType, int length)
        throws NegativeArraySizeException {
        return newArray(componentType, length);
    }

在这里需要注意的是在copyOf()方法中的那个三元表达式，也就是说在这里无论执行的true还是false，都会返回一个新的数组对象。而在这里有一行代码就是((Object)newType == (Object)Object[]).class)，这一句看起来没什么，其实可以看参数Class<? extends T[]> newType和Object会发现这两个数组对象都被强转成了Object，而==`比较符是不能比较不同类型的。例如：

1
2
3
4

public void te(){
        System.out.println("ad" == 2);
        System.out.println((String.class == Object.class));
    }

上面的代码在代码的编译期就会被提示==不可以适用于上述的两种情况.如下：

Spring出现乱码的解决办法：

若需要快速的解决乱码问题可以直接看配置文件:

后台逻辑：

在项目中的web.xml中添加Spring的字符过滤器，配置如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<filter>
        <filter-name>SpringEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>SpringEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

关于Java的代理

思路：

1. 了解Enhancer的意义
2. 查看生成的字节码（和原来的对比）
3. 分析代理的区别
4. 完成代理链

首先需要新建一个代理管理类，这个管理类会存储目标代理类，目标代理方法，以及一个List，List中存储的是一些代理类，最后是需要一个操作就是

由于当时在学习Spring的时候还是在一年前，那时候Spring才是刚到4.3还是4.5.然后做了一个项目之后便了解到了SpringBoot，于是一直在用SpringBoot，所以导致现在配置起来就有点忘记了。所以现在记录下此次配置的过程中所遇到的坑。

踩过的坑：

遇到在web.xml中分发请求的类找不到

第一个坑就是org.springframework.web.servlet.DispatcherServlet这个类一直找不到；于是在POM中添加了个各种依赖终于发现缺少Spring Web MVC这个依赖包。。。

1
2
3
4
5

<servlet>
    <servlet-name>spring-dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><!-- 需要webmvc这个jar包-->
    <load-on-startup>1</load-on-startup>
  </servlet>

Java通过反射用指定构造器初始化

首先， 一般来讲在Java中初始化一个类是通过new来操作的， 但是有一种情况却不适合这种new操作，那就是通过配置文件来进行实例化操作。

例如，在Spring中，需要加载配置文件中的类，这是比较常见的配置。 那么在Spring启动类中如何将这个类加载进容器中呢，显然进行new操作是不太现实的。 这时候就需要Java的反射操作了，Java的反射操作一般来讲有两种：分别是Class.forName()和classLoader.loadCLass() 最后都是通过newInstance() 来进行初始化，但是在这里却发现假设反射的类中含有带参数的构造器，那么此时这个newInstance()就会抛NoSuchMethodException ，这是因为newInstance()因为不加参数所以调用的是默认构造器，而反射类中已经包含了带参数的构造器，所以无不带参数构造器，遂抛出异常。

但是此时newInstance()是加不了参数的，所以若需要通过制定构造器来进行反射的话需要一个类叫Constructor，

新建一个实体类：

流的读取问题

read()方法

read()方法经常用于读取一个byte数组或者char数组，其内部的方法如下：

1
2
3

public final int read(byte b[]) throws IOException {
    return in.read(b, 0, b.length);
}

首先在读取字节流的时候是所有的字节流的顶级类的是InputStream抽象类，而继承自Inputstream的类都是带有read方法，每一个类几乎丢重写了自己的read方法，而这就是多态的一种体现。

Map接口：

1. 在map接口中的存在一个主接口：public interface Map 和一个内部接口：interface Entry
2. 其中Map接口主要功能是提供map的一些基本的操作，例如put,inEmpty,get等，而Entry接口则主要是负责遍历操作时的一些方法，例如getKey(),getValue()，setValue等

#HashMap实现类：

1. 在HaspMap这个类里面其实包含了很多的内部类：如下图：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   Node HashMap KeySet KeySpliterator EntrySet Values HashIterator KeyIterator ValueIterator EntryIterator HashMapSpliterator ValueSpliterator EntrySpliterator TreeNode

   TreeNode类： TreeNode类是一个红黑树：里面包含的是一些红黑树的操作；

   EntrySet类： EntrySet类是提供一个HashMap的遍历方式的一个类，EntrySet类里面有iterator方法，其作用在于map的一种遍历方式：

   1 2 3 4 5

   Iterator iterator =map.entrySet().iterator(); while (iterator.hasNext()){ Map.Entry<Object,Object> map1 = (Map.Entry<Object, Object>) iterator.next(); System.out.println(map1.getKey()); }

   这里涉及的知识是EntrySet是继承了AbstractSet间接实现了Set接口，而map.entrySet()方法返回的是一个Set<Map.Entry<K,V>>这个实例。

   其他的暂时还不知道有什么用

关于HashMap的其他细节