一、八大基本数据类型
1.布尔型-----boolean，boolean 类型所占存储空间的大小没有明确指定，其取值为true或false,其默认值为false。（我认为是boolean占用一个字节，但实际只用到8/1个字节，但是系统给它分配了一个字节）
2.字节型----byte，byte 类型所占存储空间大小为1个字节，其取值为-128——127，其默认值为0。
3.整型------int，int类型所占存储空间大小为4个字节，其取值为-2^31——2^31-1，其默认值为0。
4.短整型-----short，short类型所占存储空间大小为2个字节，其取值为-2^15——2^15-1，其默认值为0。
5.长整型-----long，long类型所占存储空间大小为8个字节，其取值为-2^63——2^63-1，其默认值为0。
6.字符型-----char，char类型所占存储空间大小为2个字节，其默认值为\u0000。
注意事项：不能为 0个字符。 转义字符：\n 换行 \r 回车 \t Tab 字符 \" 双引号 \\ 表示一个\ 两字符 char 中间用“+”连接，内部先把字符转成 int 类型，再进行加法运算，char 本质就是个数！二进制的，显示的时候，经过“处理”显示为字符。
7.单精度浮点型-----float，float类型所占存储空间大小为4个字节，其取值为-2^128——2^128，其默认值为0.0F；精度是小数点后面8位；在定义的float型数据后面加F 或 f；double 类型可不写后缀，但在小数计算中一定要写 D 或 X.X float 的精度没有 long 高，有效位数（尾数）短。 float 的范围大于 long 指数可以很大。 浮点数是不精确的，不能对浮点数进行精确比较。（浮点数类型）
8.双精度浮点型-----double，double类型所占存储空间大小为8个字节，其取值为-2^1024——2^1024，其默认值为0.0D，精度是小数点后面16位；浮点数字面量默认都为double类型（浮点数类型）
基本类型 占据空间 大小取值范围 默认值
boolean 不确定 true/false 0（false）
byte 一个字节 -128----127 0
int 4个字节 -2^31-2^31-1 0
short 2个字节 -2^15-2^15-1 0
long 8个字节 -2^63-2^63-1 0L
char 2个字节 \u0000
float 4个字节 -2^128-2^128 0.0F
double 8个字节 -2^1024-2^1024 0.0D
注：一个字节八位；
类型转换：
自动转换：byte-->short-->int-->long-->float-->double
强制转换：①会损失精度，产生误差，小数点以后的数字全部舍弃。②容易超过取值范围。
二、进制？进制之间的转换？
二进制：二进制，Binary，是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2，进位规则是“逢二进一”，借位规则是“借一当二”。
计算机中的二进制则是一个非常微小的开关，用“开”来表示1，“关”来表示0。
八进制：八进制，Octal，缩写OCT或O，一种以8为基数的计数法，采用0，1，2，3，4，5，6，7八个数字，逢八进1。一些编程语言中常常以数字0开始表明该数字是八进制。
十进制：十进制，Decimal，就是日常生活中用的最多的，如：1，2，3，……100，200，300……。十进制基于位进制和十进位两条原则，即所有的数字都用10个基本的符号表示，满十进一，同时同一个符号在不同位置上所表示的数值不同，符号的位置非常重要。基本符号是0到9十个数字。
十六进制：十六进制（英文名称：Hexadecimal），是计算机中数据的一种表示方法。同我们日常生活中的表示法不一样。它由0-9，A-F组成，字母不区分大小写。与10进制的对应关系是：0-9对应0-9；A-F对应10-15；N进制的数可以用0~(N-1)的数表示，超过9的用字母A-F。
下面就来看看它们之间的转换关系：
十进制转二进制
方法为：十进制数除2取余法，即十进制数除2，余数为权位上的数，得到的商值继续除2，依此步骤继续向下运算直到商为0为止。
二进制转十进制
方法为：把二进制数按权展开、相加即得十进制数。
二进制转八进制
方法为：3位二进制数按权展开相加得到1位八进制数。（注意事项，3位二进制转成八进制是从右到左开始转换，不足时补0）。
八进制转成二进制
方法为：八进制数通过除2取余法，得到二进制数，对每个八进制为3个二进制，不足时在最左边补零。
二进制转十六进制
方法为：与二进制转八进制方法近似，八进制是取三合一，十六进制是取四合一。（注意事项，4位二进制转成十六进制是从右到左开始转换，不足时补0）。
十六进制转二进制
方法为：十六进制数通过除2取余法，得到二进制数，对每个十六进制为4个二进制，不足时在最左边补零。
方法1：除8取余法，即每次将整数部分除以8，余数为该位权上的数，而商继续除以8，余数又为上一个位权上的数，这个步骤一直持续下去，直到商为0为止，最后读数时候，从最后一个余数起，一直到最前面的一个余数。
例：将十进制的(796)D转换为八进制的步骤如下：
1.将商796除以8，商99余数为4；
2.将商99除以8，商12余数为3；
3.将商12除以8，商1余数为4；
4.将商1除以8，商0余数为1；
5.读数，因为最后一位是经过多次除以8才得到的，因此它是最高位，读数字从最后的余数向前读，1434，即(796)D=(1434)O
方法2：使用间接法，先将十进制转换成二进制，然后将二进制又转换成八进制；
十进制转八进制或者十六进制有两种方法
第一：间接法—把十进制转成二进制，然后再由二进制转成八进制或者十六进制。这里不再做图片用法解释。
第二：直接法—把十进制转八进制或者十六进制按照除8或者16取余，直到商为0为止。
八进制或者十六进制转成十进制
方法为：把八进制、十六进制数按权展开、相加即得十进制数。
八进制>十六进制
方法：将八进制转换为二进制，然后再将二进制转换为十六进制，小数点位置不变。
例：将八进制的(327)O转换为十六进制的步骤如下：
1. 3 = 011；
2. 2 = 010；
3. 7 = 111；
4. 0111 = 7；
5. 1101 = D；
6.读数，读数从高位到低位，D7，即(327)O=(D7)H。
十六进制>八进制
方法：将十六进制转换为二进制，然后再将二进制转换为八进制，小数点位置不变。
例：将十六进制的(D7)H转换为八进制的步骤如下：
1. 7 = 0111；
2. D = 1101；
3. 0111 = 7；
4. 010 = 2；
5. 011 = 3；
6.读数，读数从高位到低位，327，即(D7)H=(327)O。
相互转换详细：
http://www.360doc.com/content/17/0227/22/8067272_632545159.shtml
三、原码、补码、反码？
正数的反码和补码都与原码相同。
负数的反码为对该数的原码除符号位外各位取反。
负数的补码为对该数的原码除符号位外各位取反，然后在最后一位加1
四、运算符？
算术运算符：+ - * / %
赋值运算符:=
比较运算符（关系运算符）:> >= < <= != ==
逻辑运算符:
位运算符
深入了解位运算：
===========================================================================
在Java中存在着这样一类操作符，是针对二进制进行操作的。它们各自是&、|、^、~、>>、<<、>>>几个位操作符。不管是初始值是依照何种进制，都会换算成二进制进行位
操作。接下来对这几种操作符进行一下简单的解说。
&：
作用是对运算符两側以二进制表达的操作符按位分别进行'与'运算。而这一运算是以数中同样的位(bit)为单位的。操作的规则是：仅当两个操作数都为1时。输出结果才为1。否
则为0，示比例如以下：
12的二进制为 1100
5的二进制为 0101
则12 & 5的二进制为 0100，则完整的运算式为 12 & 5 = 4;
|：
作用是对运算符两側以二进制表达的操作符按位分别进行'或'运算。而这一运算是以数中同样的位(bit)为单位的。
操作的规则是：仅当两个操作数都为0时，输出的结果才为0。
否则为1，示比例如以下：
12的二进制为 1100
5的二进制为 0101
则12 | 5的二进制为 1101。则完整的运算式为 12 & 5 = 13;
^：
作用是对运算符两側以二进制表达的操作数按位分别进行'异或'运算，而这一运算是以数中同样的位(bit)为单位的。
异或运算操作的规则是：仅当两个操作数不同的时候。对应的
输出结果才为1，否则为0，示比例如以下：
12的二进制为 1100
5的二进制为 0101
则12 | 5的二进制为 1001。则完整的运算式为 12 & 5 = 9;
~：
'取反'运算符~的作用是将各位数字取反：全部的0置为1，1置为0，示比例如以下：
12的二进制为 1100
进行取反操作为10000000 00000000 00000000 00001101
则完整的运算式为
~12 = -13
<<：
左移就是把一个数的全部位数都向左移动若干位，示比例如以下：
12的二进制为 1100
则12 << 1的二进制为 11000， 左移是在数的右边补0；则完整的运算式为12 << 1 = 24;
>>：
右移就是把一个数的全部位数都向右移动若干位，示比例如以下：
12的二进制为 1100
则12 >> 1的二进制为 0110。右移是在数的左边补0；则完整的运算式为12 >> 1 = 6;
>>>：
无符号右移一位。不足的补0。 示比例如以下：
12的二进制为 1100
则12 >> >1的二进制为 0110， 则完整的运算式为 12 >> 1 = 6;
详细见：https://www.cnblogs.com/gavanwanggw/p/7015620.html
=======================================================
三元运算符
五、switch中表达式能放的数据类型有哪些？
java 1.6(包括)以前，在switch（expr1）中，expr1只能是一个整数表达式或者枚举常量，整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐式转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long和String类型都不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中。 1.7加入的新特性可以支持String类型的数据。
注：支持String类型的原理：
http://blog.csdn.net/queenjade/article/details/44778653
原来用在switch 语句中的字符串被替换成了对应的哈希值，而 case 子句的值也被换成了原来字符串常量的哈希值。经过这样的转换，Java 虚拟机所看到的仍然是与整数类型兼容的类型。在这里值得注意的是，在case 子句对应的语句块中仍然需要使用 String 的 equals 方法来进行字符串比较。这是因为哈希函数在映射的时候可能存在冲突，多个字符串的哈希值可能是一样的。进行字符串比较是为了保证转换之后的代码逻辑与之前完全一样。
六、for循环、while循环、do while循环的区别？
while()加循环条件，一但条件不满足就不执行语句。
do-while(),判断条件满足则执行语句，条件不满足时退出循环，但是do-while()是先做再判断，所以至少要做一次循环。
for(定义循环初始条件;循环退出条件;参数自加)。
注：for循环一般跳出多重循环的外层指定for循环是利用一个标记for循环体，flag：for()，然后再利用break flag；就可以跳出循环体了。
七、continue与break的区别？
continue：
1.continue 语句中断循环中的迭代，如果出现了指定的条件，然后继续循环中的下一个迭代。
2.continue所在的循环体并没有结束。
简言之：跳过本次循环，继续执行下次循环
3.使用范围：循环结构
break：
1.break 语句可用于跳出循环。
2.break所在的循环体已经结束。
3.使用范围：循环结构或者switch---case中
相同点：如果break或者continue后面还有代码，那么这些代码将不会被执行，所以，当有代码时，编译会出错
八、数组的声明？
这里以int类型的为例：
第一种：特殊初始化，不用new关键字完成，在数组声明的同时完成初始化操作，也被称其为静态初始化。主要原因是因为采用这种初始化的方式，数组的存储空间的分配是由编译器完成的。
int[] a = {1,2,3};//int a[] ={1,2,3}
第二种：先使用new关键字创建数组，然后再分别为数组中的元素赋值，完成初始化操作。（注：如果数组元素类型为基本数据类型，在完成new操作之后，数组中的元素会自动初始化为空值，可以直接使用，但是数组元素为引用类型，在完成new操作之后，没有给引用类型赋值，就直接使用数组中的元素，会产生运行时异常。)
int[] a = new int[2]; //需要指定数组的长度
第三种：使用new关键字创建数组，同时为数组中的元素赋值，完成出事化操作。
int[] a = new int[]{1,2,3}; //与第二种方法不同，这里new不需要指定数组的长度，数组长度由其后的初始化操作确定
九、数组对应八大基本数据类型的默认值是？
Java定义了8个简单的数据类型：字节型（byte），短整型（short），整型（int），长整型（long），字符型（char），浮点型（float），双精度型（double），布尔型（boolean）.
package com.nieshenkuan.demo;
import org.junit.Test;
public class ArrayBeginArth {
@Test
public void testBoolean() {
boolean[] arr= new boolean[4];
System.out.println(arr[2]);//false
}
@Test
public void testByte() {
byte[] arr= new byte[4];
System.out.println(arr[2]);//0
}
@Test
public void testShort() {
short[] arr= new short[4];
System.out.println(arr[2]);//0
}
@Test
public void testChar() {
char[] arr= new char[4];
System.out.println(arr[2]);//空：/u0000
}
@Test
public void testInt() {
int[] arr= new int[4];
System.out.println(arr[2]);//0
}
@Test
public void testLong() {
long[] arr= new long[4];
System.out.println(arr[2]);//0
}
@Test
public void testFloat() {
float[] arr= new float[4];
System.out.println(arr[2]);//0.0
}
@Test
public void testDouble() {
double[] arr= new double[4];
System.out.println(arr[2]);//0.0
}
}
boolean默认值为false，byte、short、int、long默认为0L，char默认为空，/u0000；float、double默认值为0.0；
十、数组有length属性，String有length()方法。
十一、Arrays工具类的使用？
package com.nieshenkuan.demo;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
public class ArraysTest {
String[] array = new String[] { "a", "c", "2", "1", "b" };
Integer[] ints = new Integer[] { 5, 1, 4, 3, 2 };
/* * asList这个方法可以把数组转换成List,List提供了很多的操作方法，更便于使用。 */
@Test
public void test1() {List lists = Arrays.asList(array);
System.out.println(lists);
}
/*
* sort比较常用了，根据元素按照自然排序规则排序，也可以设置排序元素的起始位置。
*/
@Test
public void sort() {
// Arrays.sort(array); for(String str : array){ System.out.println(str); }
Arrays.sort(array, 2, 4);
System.out.println(Arrays.deepToString(array));// [a, c, 1, 2, b]
}
/*
* binarySearch查找目标元素所在的位置，注意需要先进行排序。
*/
@Test
public void binarySearch() {
// binarySearch需要保证是排好序的
System.out.println(Arrays.binarySearch(array, "c"));// -6
Arrays.sort(array);
System.out.println(Arrays.binarySearch(array, "c"));// 4
}
/*
* copyOf拷贝数组，第一种用法，如果目标长度不够，会使用0进行补位。第二种用法，支持拷贝目标起始位置到结束为止的数组。
*/
@Test
public void copyOf() {
// 如果位数不够，需要补位
Integer[] result = Arrays.copyOf(ints, 10);
for (int i : result) {
System.out.println(i);
}
System.out.println("----------------------------------------->");
// 如果位数够，就取最小的数组
result = Arrays.copyOf(ints, 3);
for (int i : result) {
System.out.println(i);
}
System.out.println("----------------------------------------->");
//
result = Arrays.copyOfRange(ints, 2, 4);
for (int i : result) {
System.out.println(i);
}
}
/*
* deepEquals深度比较、deepHashCode生成hashcode、deepToString深度打印 这几个方法基本都是采用递归的写法使用。
*/
@Test
public void deepTest() {
String[] array2 = new String[] { "a", "c", "2", "1", "b" };
System.out.println(Arrays.deepEquals(array, array2));// 深度比较两个数组是否相同
System.out.println(Arrays.deepHashCode(array));
System.out.println(Arrays.deepHashCode(array2));// 如果两个数组deepEquals，那么他们的hashcode一定相同
// 格式化输出数组
System.out.println(Arrays.deepToString(array));
}
/*
* equals比较 对比两个数组是否相等
*/
@Test
public void equals() {
String[] array2 = new String[] { "a", "c", "2", "1", "b" };
// 1 对比引用是否相同
// 2 对比是否存在null
// 3 对比长度是否相同
// 4 挨个元素对比
System.out.println(Arrays.equals(array, array2));
}
/*
* fill 基于目标元素填充数组
*/
@Test
public void fill() {
Arrays.fill(array, "test");
System.out.println(Arrays.deepToString(array));// [test, test, test, test, test]
}
/*
* toString 打印数组元素
*/
@Test
public void string() {
System.out.println(Arrays.toString(array));// [a, c, 2, 1, b]
}
/*
* toStream 把数组转换成stream,然后可以使用java8的stream特性了。
*/
@Test
public void toStream() {
Arrays.stream(array).forEach(s -> System.out.println(s));
}
/*
* parallelPrefix 这个有点像spark的reduceByKey，即根据传入的方法一次计算：
*/
@Test
public void parallelPrefix() {
Arrays.parallelPrefix(ints, (x, y) -> (x + y));
System.out.println(Arrays.deepToString(ints));// [5, 6, 10, 13, 15]
}
/*
* parallelSetAll 这个方法相当于stream.map会挨个元素遍历执行方法
*/
@Test
public void parallelSetAll() {
Arrays.parallelSetAll(ints, x -> x * x);
System.out.println(Arrays.toString(ints));// [0, 1, 4, 9, 16]
}
/*
* setAll 这个方法与上面类似，只不过不是并行的
*/
@Test
public void setAll() {
Arrays.setAll(ints, x -> x * 2);
System.out.println(Arrays.toString(ints));
}
}
