Java基础

JVM

• JVM介绍

  JVM是Java Virtual Machine（Java虚拟机）的缩写，

  JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。

  Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。

  JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台上不加修改地运行。

  JVM在执行字节码时，实际上最终还是把字节码解释成具体平台上的机器指令执行。

  http://www.cnblogs.com/sunada2005/p/3577799.html

equals与==

• 区别（20180401）

    1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等； 
    如果作用于引用类型的变量，则比较的是所指向的对象的地址 
    
    2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量 如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址； 
    诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。
  

• 示例：

  https://www.nowcoder.com/questionTerminal/04fd8ddb19024dd0acd89bbff85c0a50

String

• String字符串拼接方式，好处与不足

  1.+号直接拼接
  2.append()
  3.Format》》String.format("%s和%s一起LOL", new String[]{ "小明", "小强"});
  4.StringBuilder
  
  stringBuilder效率高，不产生新的对象
  string对象操作的时候，总是产生新的对象，
  然后自动回收旧的对象(如果没用的话)，效率是比stringBuilder在原对象上进行操作来的低的
  

  参考链接:

  http://www.cnblogs.com/gc2013/p/4351015.html

• String 对象

  String对象是不可变的，你可以给一个String对象加任意多的别名。因为String对象具有只读特性，所以指向它的任何引用都不可能改变它的值。
  不可变性也会带来一定的效率问题。

http和https

• http和https

    一、https协议需要到ca申请证书，一般免费证书很少，需要交费。 
    二、http是超文本传输协议，信息是明文传输，https 则是具有安全性的ssl加密传输协议。 
    三、http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。 
    四、http的连接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、
    身份认证的网络协议，比http协议安全。
  

Java数据类型

• 基本数据类型（四类八种）

    整型( byte short int long )
    浮点型( float double )
    字符型( char )
    布尔型( boolean )
  

• 引用数据类型

    数组型 
    接口型 
    类类型
  

• 数据类型图示(java数据类型.png)

  

注意：byte,short,char都可以隐含转换为int，long不能转换为int

char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中可以存储汉字(未包含在unicode编码中的特殊汉字除外).
unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

堆栈区域

• 成员变量存在于堆内存中，默认有初始值。

• 局部变量存在于栈内存中，没有默认初始值。

• 图解1(堆栈图解1.png)

  

• 图解2(堆栈图解2.png)

  

集合简单总结

• 常用总结比较(集合总结2.png)

由此可得，HashMap可以存储一个key为null,多个value为null的键值对。

Collection和Map框架结构

• 比较常用的Collection子类与Map子类简图(Collection和Map框架结构.png)

泛型与容器的关系

容器，即:存对象的地方，当把对象存进容器中时，就转变成了Object类型的对象，那么在取出对象元素时，就需要做类型转换(向下转换)，那么就可能发生类型转换异常(ClassCastException)，这个时候，如果有一种约束，来确保存进去的是一种具体类型，那么取出时就不用再做类型转换的工作了，那么也就可以有效防止类型转换异常的出现了，那么这种约束，就是java中的泛型，一种对容器概念的有效补充。

简单的容器分类

• 分类图(简单的容器分类.png)

  

---

接口类型的子类对象的意义

• 多态的体现(接口类型的子类对象的意义.png)

  

LinkedList与ArrayList

• LinkedList

  LinkedList底层是由双向循环链表实现，里面的数据在逻辑上的存储是连续的，连续自然也就有顺序了

• LinkedList与ArrayList的比较

  LinkedList也像ArrayList一样实现了基本的List接口，但是它执行某些操作时比ArrayList更高效（在List的中间插入和移除），但在随机访问操作方面却要逊色一些。

  ArrayList底层的实现是数组，所以用下标访问的速度比较快，但是插入和删除元素，会有移动元素的开销，所以速度比LinkedList差。
  LikedList底层是链表实现的，所以插入和删除元素时间复杂度较LinkedList好，但是随即访问需要遍历元素，所以效率比ArrayList差

Set

Set不保存重复元素

Iterator与Iterable

• 不同的包

  java.lang.Iterable

  java.util.Iterator

数组增加元素

• 数组是定长，需要用Arrays.asList转换为List,再转换为ArrayList才能进行写操作

    String[] arr = new String[2];
    arr[0] = "1";
    arr[1] = "2";
    List<String> listArr = new ArrayList<>(Arrays.asList(arr));
    listArr.add(2,"5");
  

java Native 方法

• native方法

  native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。Java语言本身不能对操作系统底层进行访问和操作，但是可以通过JNI接口调用其他语言来实现对底层的访问。

• JNI

  JNI是Java本机接口（Java Native Interface），是一个本机编程接口，它是Java软件开发工具箱（Java Software Development Kit，SDK）的一部分。JNI允许Java代码使用以其他语言编写的代码和代码库。Invocation API（JNI的一部分）可以用来将Java虚拟机（JVM）嵌入到本机应用程序中，从而允许程序员从本机代码内部调用Java代码。

• Object是抽象类吗？

  查看Object源码可以看到，许多方法是没有实现体的，但是Object类并不是抽象类，因为这些没有方法体的方法用Native修饰，其实现体并不是java语言写的。

引用传递与值传递

• 引用传递与值传递

  JAVA里除了8种基本类型传参数是值传递，其他的类对象传参数都是引用传递

java中的编译时类型和运行时类型

• 运行时类型与编译时类型

  Java中的许多对象（一般都是具有父子类关系的父类对象）在运行时都会出现两种类型：编译时类型和运行时类型，例如：Person person = new Student();这行代码将会生成一个person变量，该变量的编译时类型是Person，运行时类型是Student。

  Java的引用变量有两个类型，一个是编译时类型，一个是运行时类型，编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，会出现所谓的多态

jdk打包与解压

• 打包命令

    jar -cvf diaowen.war diaowen
  

• 解压命令

    jar xvf diaowen.war
  

多个数组/lit遍历分别赋值到实体类的属性

• 数组操作(List一样原理)

    String[] opinionUserList = opinionUser.split("###");
    String[] opinionContentList = opinionContent.split("###");
    String[] deptList = dept.split("###");
    if (opinionUserList != null && opinionUserList.length > 1) {
        for (int i = 0; i < opinionUserList.length; i++) {
            DocOpinion des = new DocOpinion();
            //属性拷贝
            BeanUtils.copyProperties(docOpinion, des);
            
            des.setOpinionUser(opinionUserList[i]);
            des.setOpinionContent(opinionContentList[i]);
            des.setOpinionDept(deptList[i]);
            
            //其他值(在if外层已经获取到值了)
            des.setOpinionCode(code);
            des.setOpinionCodeName(codeName);
    
            des.setStatus("0");
            des.setSystemNo("ROOT");
           
            //数据插入
            docOpinionMng.insertDocOpinion(des);
    }
  

注解@Target

• @Target:注解的作用目标

   //Class, interface (including annotation type), or enum declaration
   @Target(ElementType.TYPE)   //接口、类、枚举
   
  //Field declaration (includes enum constants)
   @Target(ElementType.FIELD) //字段、枚举的常量
   
   //Method declaration
   @Target(ElementType.METHOD) //方法
   
  //Formal parameter declaration
   @Target(ElementType.PARAMETER) //方法参数
   
  //Constructor declaration
   @Target(ElementType.CONSTRUCTOR)  //构造函数
   
  //Local variable declaration
   @Target(ElementType.LOCAL_VARIABLE)//局部变量
   
   //Annotation type declaration
   @Target(ElementType.ANNOTATION_TYPE)//注解
   
  //Package declaration
   @Target(ElementType.PACKAGE) ///包

jdk8 File读写新方式

• try里写方法

package com.example.demo;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileDemo {


    public static void main(String[] args) {
        fileUtil();
    }

    public static void fileUtil() {
        try (
                FileInputStream fis = new FileInputStream("/Users/xdclass/Desktop/test.txt");
                BufferedInputStream bis = new BufferedInputStream(fis);

                FileOutputStream fos = new FileOutputStream("/Users/xdclass/Desktop/copy.txt");
                BufferedOutputStream bos = new BufferedOutputStream(fos);
        ) {
            int size;
            byte[] buf = new byte[1024];
            while ((size = bis.read(buf)) != -1) {
                bos.write(buf, 0, size);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

List去除重复元素

package com.example.demo;

import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;

public class RemoveDuplicateElement {

    public List<String> initList = Arrays.asList("张三","李四","张三","周一","刘四","李强","李白",
"张三","李强","王五");


    /**
     * 1.Stream 去重（推荐****）
     */
    @Test
    public void remove6() {
        List<String> list = new ArrayList(initList);
        list = list.stream().distinct().collect(Collectors.toList());
        System.out.println(list);
        //[张三, 李四, 周一, 刘四, 李强, 李白, 王五]
    }

    /**
     * 2.LinkedHashSet 去重(保证顺序一直推荐***)
     */
    @Test
    public void remove5() {
        List<String> list = new ArrayList(initList);
        List<String> list2 = new ArrayList(new LinkedHashSet(list));
        System.out.println(list2);
        //[张三, 李四, 周一, 刘四, 李强, 李白, 王五]
    } 

    /**
     * 3.Set 去重（顺序不一致）
     * 结果虽然正确，但元素顺序和原始 List 不一致，如果要保证顺序性，可以把 HashSet 换成 LinkedHashSet：
     */
    @Test
    public void remove4() {
        List<String> list = new ArrayList(initList);
        List<String> list2 = new ArrayList(new HashSet(list));
        System.out.println(list2);
        //[李强, 李四, 张三, 周一, 李白, 王五, 刘四]
    }

    /**
     * 4.for 循环添加去重
     */
    @Test
    public void remove1() {
        List<String> list = new ArrayList(initList);
        List<String> list2 = new ArrayList<>();
        for (String element : list) {
            if (!list2.contains(element)) {
                list2.add(element);
            }
        }
        System.out.println(list2);
        //[张三, 李四, 周一, 刘四, 李强, 李白, 王五]
    }


    /**
     * 5.for 双循环去重
     */
    @Test
    public void remove2() {
        List<String> list = new ArrayList(initList);
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = list.size() - 1; j > i; j--) {
                if (list.get(j).equals(list.get(i))) {
                    list.remove(j);
                }
            }
        }
        System.out.println(list);
        //[张三, 李四, 周一, 刘四, 李强, 李白, 王五]
    }

    /**
     * 6.for 循环重复坐标去重
     */
    @Test
    public void remove3() {
        List<String> list = new ArrayList(initList);
        List<String> list2 = new ArrayList(initList);
        for (String element : list2) {
            if (list.indexOf(element) != list.lastIndexOf(element)) {
                list.remove(list.lastIndexOf(element));
            }
        }
        System.out.println(list);
        //[张三, 李四, 周一, 刘四, 李强, 李白, 王五]
    }


}