Java基础-杂货铺

初学Java时总结的一些基础，对于Java经验者们看来这些都是很简单的基础知识，但正所谓：“根基不牢，地动天摇”。也不要忽略了基础的重要性，温故而知新。本篇文章不是什么专题，只是记录，有不对的地方欢迎各路神佛批评指正。

原子性：如果把一个事务可看作是一个程序,它要么完整的被执行,要么完全不执行。这种特性就叫原子性。

源代码中一些常见标识：

E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
？ -  表示不确定类型

细小的了解，省去刚开始看源代码时一脸懵。

IP和端口：ip相当于街道，端口就相当于门牌号。

常见符号：

\n换行相当于回车，回到下一行最开始位置；

\t横向跳格，将光标移动下一个水平制表位置；

\b退格；

\r回车，Linux、unix表示返回到当行的最开始位置，Mac OS中表示换行且返回到下一行最开始位置；

\f走纸换页。

构造方法：当新对象被创建的时候，构造方法会被调用。每一个类都有构造方法。在程序员没有给类提供构造方法的情况下，Java编译器会为这个类创建一个默认的构造方法。如果想为一个类传入参数，则重定义它的构造方法即可。

Java最基础:

基础数据类型：byte short int long float double char boolean(一定注意String不是基础类型)

访问权限控制符：private  public  protected    
1、private修饰词，表示成员是私有的，只有自身（本class）可以访问；       
2、protected，表示受保护权限，体现在继承，即子类可以访问父类受保护成员，    
同时相同包内的其他类也可以访问protected成员（相同包访问权限）。       
3、无修饰词（默认），表示包访问权限（friendly， java语言中是没有friendly这个    
修饰符的，这样称呼应该是来源于c++ ）    
，同一个包内可以访问，访问权限是包级访问权限（等同于protected）；      
4、public修饰词，表示成员是公开的，所有其他类都可以访问；    
与类相关控制符：class extends abstract interface implements new this super    
与方法相关控制符：void return    
控制语句：if else switch case for while break continue default    
逻辑值：true false    
异常处理：try catch throw throws finally     
网络：socket serversocket    
用于包，类，接口：package import final static native synchronized    
String user,password,userage;    
常量必须使用关键字final: final float 2.2f 不可变的量    
final String user,password,userage;    
数据类型：整型：byte(字节型)，short(短整型),int(整型),long(长整型)    
八进制（0~7）必须以0开头，例：098，02340，十六进制（0~7 or a~e or A~E）：    
必须0x或0X开头。内存：byte(1byte) 取值范围：byte 浮点型：float(单精度),double(双精度)，默认小数是double型    
字符型：char类型表示单个字符，一个字符内存2byte。用单引号’’。

运算符：

一元运算符：x++:使用x之后使x加1(x--同理)。++x:使用x之前使x加1(--x同理)        
二元运算符：+（加），-（减），*（乘），/（除），%（取余），除和取余只出整数，        
如果有小数直接去掉，不会进行四舍五入        
关系运算符：==(等于),!=(不等),>(大于),<(小于),>=(大于等于),<=(小于等于)，=是赋值运算符        
逻辑运算符：&&(与),||(或),!(非)        
赋值运算符：+=:i+=8→i=i+8;-=:i-=8→i=i-8。*=:i*=8→i=i*8。/=:i/=8→i=i/8,%=:i%=8→i=i%8。&=:i&=8→i=i&8;|=:i|=8→i=i|8        
^=,~=,<<=,>>=,>>>=        
位运算符：&(按位与),|(按位或),^(按位异或),~(按位取反)        
针对二进制，关于二进制        
十进制整数转二进制数：“除以2取余，逆序排列”        
二进制转十进制：方法：“按权展开求和”        
按位与&，对两个二进制的数进行”与”运算，即：0&0=0,0&1=0,1&0=0,1&1=1。        
按位或|，对两个二进制的数进行“或”运算，即：0|0=0，0|1=1，1|0=1，1|1=1。        
按位异或^,对两个二进制数进行”异或”运算，即：0^0=0,0^1=1,2^0=1,1^1=0。        
按位取反运算~,对两个二进制数进行按位取反运算，即：~0=1，~1=0。        
移位运算符：        
>>向右移：4>>1==2 所有二进制数移动一位，<<向左移：4<<2==16 所有二进制数移动2位，右边控位补0，左边移走部分舍去
>>>向右移：-4>>>1==-2无符号右移动，所有二进制数移动一位，不管正数负数左边空位补0        
无符号右移作用：数据变换时非常重要，比如对byte b;做无符号右移，在众多散列、加密、压缩、影音媒体编码、        
序列化格式都会用到。如果没有这个无符号右移，就需要用更大的空间去做有符号右移。比如byte就需哟short，short        
就需要int去做，浪费空间和时间。所谓“左移两位是乘以4(2的2次方)，右移两位是除以4” 原先都是指在无符号环境下成立。        
只因java没有无符号的基础类型，所以你理解成有符号下才是这样。        
三元运算符：Java中只有一个三元运算符，“？：”，语法格式：逻辑表达式？表达式1:表达式2        
三元运算符规则：首先判断表达式的值。如果是true，三元表达式的值为表达式1的值，否则是表达式2的值。        
对象运算符：instanceof运算符用来检查是否是类的对象，其返回值是boolean类型的值。
语法格式：A instanceof B,若A是B的对象，则返回true,否则返回false。

switch语句：switch语句又称多分支开关语句，和case一起使用，其功能是根据某表达式值多case引导的多分支语句中选择一个来执行。switch首先计算表达式的值，如果表达式后面常量值相同，就执行case后面语句块，直到遇到break为止，若没有一个常量与表达式相同，则执行default语句后面的语句块n+1。default语句可有可无；default语句不存在，并所以常量值和表达式值不相同，switch语句不会进行任何处理。

循环语句：for,while,do-while三种循环语句    
for 循环是java中最常见的循环语句，一般用在循环次数已知情况下。    
for (初始表达式：条件表达式：迭代因子)     
{    
循环体语句块    
}    
例子：    
for (int n; n>0; n++),for(int n;n<15;n--)：当n小于一个值时候后面用n--。当n大于一个值时候后面用n++，小于对应--，大于对应++。    
条件表达式是boolean类型，只能是true或flase，为真的时候执行循环体语句，false时候退出循环体执行后面程序。迭代因子修改变量，改变循环条件。    
while是先判断条件是否满足，如果第一次循环就不满足直接跳出循环。这就是while：先判断后执行。    
while (循环条件) {    
循环体语句块    
}    
循环条件也是boolean类型。while循环之前，一定是判断循环条件是否满足如果不满足直接跳出循环去执行循环之后的语句。    
do-while语句：    
Do-while与for,while功能类似，都是循环执行循环体语句块。它是先执行do后面循环体语句，然后对while后面的布尔表达式进行判断，    
如果为true,再次执行do后面的循环体语句，并再次对对布尔表达式的值进行判断；否则，结束循环语句。Do-while先执行一遍再判断，    
特点：先执行，后判断。语句格式：    
do {    
循环体语句块    
} while (循环条件) ;    
break和continue针对循环语句中的循环提供附加控制，使程序设计更灵活。    
break终止循环语句。在某些情况下终止一次循环，它可以在循环中多次出现。    
continue经常和各种循环语句一起连用，continue语句用来结束本次循环，即跳过循环体中的continue语句后面的语句，回到循环体的条件测试部分继续执行。    
break和continue都是跳出循环：但continue语句只结束本次循环，而不终止整个循环的执行。break是结束整个循环过程，不再判断执行循环的条件是否成立。

接口和抽象类的区别：

1.接口中所有的方法隐含的都是抽象的。
而抽象类则可以同时包含抽象和非抽象的方法。
2.类可以实现很多个接口，但是只能继承一个抽象类。
3.类如果要实现一个接口，它必须要实现接口声明的所有方法。
但是，类可以不实现抽象类声明的所有方法，（非抽象类必须实现抽象类所有方法）
当然，在这种情况下，类也必须得声明成是抽象的。
4.抽象类可以在不提供接口方法实现的情况下实现接口。
5.Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。
6.Java接口中的成员函数默认是public的。
抽象类的成员函数可以是private，protected或者是public。
7.接口是绝对抽象的，不可以被实例化。
抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。

使用接口的意义在于接口为绝对抽象的，相当于一个目录，通过多实现，实现出同一个接口可以有多种实现模式    有了接口貌似抽象类就没什么用了，其实不然，抽象类虽然不是接口无法实现，只能单继承，但是带有继承属性的话    子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。子类继承完父类后可以覆盖父类方法在类的继承过程中，如果子类中新增的变量和方法与父类中原有的变量和方法同名，则会覆盖从父类继承来的同名变量和方法。覆盖又分为变量覆盖和方法覆盖，变量覆盖是指父类和子类中的变量名相同，数据类型也相同。方法覆盖又称方法重写，与之前介绍的方法重载相比，方法覆盖的要求更严格！！：不仅要求父类与子类中的方法名称相同，而且参数列表也要相同，只是实现的功能不同。接口之间可以多继承。

HashCode：

1.hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap等，hashCode是用来在散列存储结构中确定对象的存储地址的
2.如果两个对象相同，就是适用于equals(java.lang.Object) 方法，那么这两个对象的hashCode一定要相同；
3.如果对象的equals方法被重写，那么对象的hashCode也尽量重写，并且产生hashCode使用的对象，一定要和equals方法中使用的一致，否则就会违反上面提到的第2点
4.两个对象的hashCode相同，并不一定表示两个对象就相同，也就是不一定适用于equals(java.lang.Object) 方法，只能够说明这两个对象在散列存储结构中，如Hashtable，他们“存放在同一个篮子里”。

多态：

一个接口，多种实现。特点：1. 消除类型之间的耦合关系2. 可替换性3. 可扩充性4. 接口性5. 灵活性6. 简化性

public interface A {        
    public void water();    
}  
public class B implements A{        
    @Override    
    public void water() {    
        System.out.println("The sea is made up of water.");
    }    
}   
public class C implements A{  
    @Override    
    public void water() {    
        System.out.println("The river is made up of water.");
    }    
}  
public class Work {        
    public void work(A a) {    
        a.water();
    }    
}
public class Output {        
    public static void main(String[] args) {    
        Work w = new Work();
        A a0 = new B();
        A a1 = new C();
        w.work(a0);
        w.work(a1);
        a0.water();
        a1.water();
    }    
}

内部类的作用：

1.内部类可以很好的实现功能隐藏：一般的非内部类，是不允许有private与protected权限的，但内部类有。
2.内部类可以无条件的访问外围类的所有元素。
3.内部类可以实现多重继承（在类当中再写几个内部类，分别继承想要继承的类）
4.避免修改接口而实现同一个类中两种同名方法的调用：如果你的类继承一个类还要实现一个接口，但是继承的父类和接口中有一个方法同名，这时需要内部类，用内部类实现接口就不会出现此种情况。

内部类分为：1.匿名类，2.静态类，3.成员类（全局类），4.局部类

匿名类：没有名字的java内部类。匿名类没有明确的类定义格式，是指类的定义和类对象创建合并在一起的情况。匿名类属于唯一一个对象

静态类：作为类的静态成员存在于某个类中，也是内部类的一种，静态类加关键字static。

一些基础排序：

冒泡排序：它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来，直到没有元素再需要交换，排序完成。

快速排序：从数列中挑出一个元素，称为“基准”，重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。

选择排序：在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，再从剩余未排序元素中继续寻找最小（大）元素，然后放到排序序列末尾。选择排序是一种简单直观的排序方法，每次寻找序列中的最小（大）值，然后放在最末尾的位置。

插入排序：

1.从第一个元素开始，该元素可以认为已经被排序
2.取出下一个元素，在已经排序的元素序列中从后向前扫描
3.如果该元素（已排序）大于新元素，将该元素移到下一位置
4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5.将新元素插入到该位置中，重复2步骤

归并排序：

建立在归并操作上的一种有效的排序算法，归并是指将两个已经排序的序列合并成一个序列的操作。

线程：一个程序的执行流程。

String,StringBuffer和StringBuilder区别：

String是字符串常量，字符串长度不可变    
/** The value is used for character storage. */    
private final char value[];    
/** The offset is the first index of the storage that is used. */    
private final int offset;    
/** The count is the number of characters in the String. */    
private final int count;    
以上看出用于存放字符的数组被声明为final的，因此只能赋值一次，不能改变。    
StringBuffer（JDK1.0）：字符串变量（Synchronized，即线程安全）    
如果要频繁对字符串内容进行修改，出于效率考虑最好使用StringBuffer，    
如果想转成String类型，可以调用StringBuffer的toString()方法。    
Java.lang.StringBuffer线程安全可变字符序列。可将字符串缓冲区安全的用于多个线程。    
StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。    
每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。    
append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。    
例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。    
StringBuilder(JDK5.0)：字符串变量（非线程安全）    
在内部，StringBuilder被当做一个包含字符序列的边长数组。    
此类提供一个与StringBuffer兼容的API，但不保证同步。该类被设计对StringBuffer的一个简单替换用在字符串缓冲区被单线程使用的时候。    
String 类型和StringBuffer的主要性能区别：String是不可变的对象, 因此在每次对String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容    
的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，性能就会降低。

List,set,Map特点：

List特点：元素有放入顺序，元素可重复
Map特点：元素按键值对存储，无放入顺序
Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的
HashCode决定的，其位置其实是固定的）
List接口有三个实现类：LinkedList，ArrayList，Vector
LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身内存地址的同时还存储下一个元
素的地址。链表增删快，查找慢
ArrayList和Vector的区别：ArrayList是非线程安全的，效率高；Vector是基于线程安全的，效率低
Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet
SortedSet接口有一个实现类：TreeSet（底层由平衡二叉树实现）
Query接口有一个实现类：LinkList
Map接口有三个实现类：HashMap，HashTable，LinkeHashMap
HashMap非线程安全，高效，支持null；HashTable线程安全，低效，不支持null
SortedMap有一个实现类：TreeMap
其实最主要的是，list是用来处理序列的，而set是用来处理集的。Map是知道的，存储的是键值对
set 一般无序不重复.map kv 结构 list 有序
Map的遍历：for (Map.Entry entry : map.entrySet())
List的遍历：for(String tt:List)
合并两个list，list1.addAll(list2);

equals和==区别：

"=="        
    1、用于基本数据类型的比较    
    2、判断引用是否指向堆内存的同一块地址。    
equals        
用于判断两个变量是否是对同一个对象的引用，即堆中的内容是否相同，返回值为布尔类型        
例子一：对象不同，内容相同，"=="返回false，equals返回true        
String s1 = new String("java");        
String s2 = new String("java");        
System.out.println(s1==s2);            //false        
System.out.println(s1.equals(s2));    //true        
例子二：同一对象，"=="和equals结果相同        
String s1 = new String("java");        
String s2 = s1;        
System.out.println(s1==s2);            //true        
System.out.println(s1.equals(s2));    //true        
String作为一个基本类型来使用        
如果值不相同，对象就不相同，所以"==" 和equals结果一样        
String s1 = "java";        
String s2 = "java";        
System.out.println(s1==s2);            //true        
System.out.println(s1.equals(s2));    //true

isEmpty()是判断字符串value.length的长度=0，当str==""时，str.length长度是0，当str="0"时，长度为1。

subString(begin,end); end=最后一个字符索引+1

POJO（Plain Ordinary Java Object）简单的Java对象，实际就是普通JavaBeans，是为了避免和EJB混淆所创造的简称。