JAVA基础：下部分总结

易错：
方法调用时：
l 当调用方法时可以理解为其调用的是副本，如果传入的数值为基本数据类型（包含String类型），形式参数的改变对实际
参数不影响
l 当调用方法时其调用的是该数据的物理内存地址，如果传入的数值为引用数据类型（String类型除外），形式参数的改变对实际
参数有影响
接口 Comparable实现compare to方法应用在collections.sort方法上
接口 实现Serializable可将该类序列化
接口 Runnble实现run方法应用在线程处理run方法中的内容

U1下部分概念理解

堆栈概念：（自我理解）
堆中存放new出来一个地址存放对象；是存放new出来的数据，以及非静态常量
栈中（压栈）存放的是压入执行中进入另一个方法时标记进入前在执行这一步的地址进入栈中，然后执行完此方法（弹栈）返回此地址
代码区：存放代码；
static静态的，用静态修饰的属性、方法存在于静态空间，随类的加载而加载可不通过对象直接通过类调用静态属性及方法，对象可对同一个静态属性进行操作
*重写对权限修饰符有要求,子类的方法的权限>=父类的方法的权限
*调用类时其调用顺序：静态代码块/局部代码块/构造代码块/构造方法的执行顺序（静态代码块只执行一次，应用比较少）
内部类的调用：外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
代码排版ctrl+alt+L
物理内存地址是应用数据的地址（HashCode并不能指内存地址自我理解指该数据用HashCode表示），源码上表示相当复杂，在运用上暂时可这样理解）
==与equal的区别：
Equal比较对象HashCode内存地址、
可以比较引用数据类型（比较物理内存地址System.identityHashCode+“系统内存的位置而不是该数据的表示值若是该变量名的.identityHashCode其便是HashCode，其相等”）也可以比较基本数据
//字符串常量 池
String str1= “猴子”;
//下面str2 引用来自字符串常量池中的str1
String str2 = new String(“猴子”);
System.out.println(str1.hashCode()); //937628
System.out.println(str2.hashCode()); //937628
System.out.println(System.identityHashCode(str1));
System.out.println(System.identityHashCode(str2));
//比较hashCode
System.out.println(str1.equals(str2)); //true
//比较identityHashCode
System.out.println(str1str2); //false
}

String类：
字符串常用方法：
字符串转换成字符数组：toCharArray() 返回值类型是字符数组
字符串转换大写： toUpperCase()

字符串转换小写： toLowerCase()
忽略大小写比较字符串是否相等: equalsIgnoreCase()
1.判断字符串是否以指定的前缀开始：startsWith(String prefix)
2.判断字符串是否以指定的后缀结束:endsWith(String suffix）
3.判断字符串是否包含指定子串 :contains(CharSequence c);
1.字符串长度： length() , 返回值类型是int
2.截取字符串作为子串： substring(int beginIndex) 包含起始索引
3.截取字符串作为子串： substring(int beginIndex,int endIndex) 包含起始索引,不包含结束索
引

+连接和StringBuilder对象append方法连接
+和StringBuilder都能做字符串拼接,但是StringBuilder的更节约内存
因为利用+拼接字符串,每使用一次,底层都会新创建一个StringBuilder对象,然后利用这个
StringBuilder对象拼接
而我们手动创建的StringBuilder只利用一个就可以完成拼接,以后拼接字符串优先考虑
StringBuilder
StringBuilder是线程不安全的，效率高，
StringBuffer是线程安全的，效率低。

Date类：
DateFormat 是日期/时间格式化子类的抽象，用SimpleDateFormat创建对象去格式化时间
将Date对象放在SimpleDateFormat的对象format方法里转化成想要的格式字符串
字符串格式的时间对象也可以通过SimpleDateFormat的对象parse方法里转化成想要的时间格式
Calendar日历类是抽象类
建立对象的方法1 Calendar ob=Calendar.Instance （调用日历类的静态方法返回值类型是Calendar） /2 Calendar ob= new GregorianCalendar()向上转型创建日历类对象
通过对象的get方法参数是Calendar的静态方法（年月日周等）

collection接口：
List集合接口 （有序，不唯一）
ArrayList 序列 ，底层是对象（引用）数组，查询效率高，增删效率低
LinkedList 链表 前一个元素存储下一个元素的地址值，查询效率低（从链头开始），增删效率
高
Set集合接口 （无序, 唯一）
HashSet 唯一原理 先比较HashCode,再比较equals
Map有方法entry.set用Set集合接收
IO流：
1，明确源和目的。
数据源：就是需要读取，可以使用两个体系：InputStream、Reader；
数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；
2，操作的数据是否是纯文本数据？
如果是：数据源：Reader
数据汇：Writer
如果不是：数据源：InputStream
数据汇：OutputStream
3，虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？
明确操作的数据设备。
数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)
数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)。
4，需要在基本操作上附加其他功能吗？比如缓冲。
如果需要就进行装饰。

线程：
多线程安全问题的原因：
一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。
导致到了错误数据的产生。
涉及到两个因素：
1，多个线程在操作共享数据。
2，有多条语句对共享数据进行运算。
原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。
方法：
只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。

synchronized(对象) { // 任意对象都可以。这个对象就是锁。
需要被同步的代码；
}

好处：解决了线程安全问题。
弊端：相对降低性能，因为判断锁需要消耗资源。用锁时要避免产生死锁
当同步函数被static修饰时，这时的同步用的是哪个锁呢？类名.class
等待唤醒机制：涉及的方法：
锁的对象方法存在于Object类中
wait:将同步中的线程处于冻结状态。释放了执行权，释放了资格。同时将线程对象存储到线程池中。
notify：唤醒线程池中某一个等待线程。
notifyAll:唤醒的是线程池中的所有线程。
wait和sleep区别： 分析这两个方法：从执行权和锁上来分析：
wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。
sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。
wait：线程会释放执行权，而且线程会释放锁。
Sleep：线程会释放执行权，但不是不释放锁。
---------< java.lang.Thread >----------
interrupt()：中断线程。
setPriority(int newPriority)：更改线程的优先级。
getPriority()：返回线程的优先级。
toString()：返回该线程的字符串表示形式，包括线程名称、优先级和线程组。
Thread.yield()：暂停当前正在执行的线程对象，并执行其他线程。
setDaemon(true)：将该线程标记为守护线程或用户线程。将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。
join：临时加入一个线程的时候可以使用join方法。
当A线程执行到了B线程的join方式。A线程处于冻结状态，释放了执行权，B开始执行。A什么时候执行呢？只有当B线程运行结束后，A才从冻结状态恢复运行状态执行。

网络编程：
UDP：DatagramSocket. 封装了udp传输协议的socket对象。创建时可以自己定义端口值，有send方法和receive
DatagramPacket 通过这个对象中的方法，就可以获取到数据包中的各种信息，将数据打包成byte数组，
Socket：send出去的有Packet包装的byte数组，数组长度，地址InetAddress.getbyName(IP)，端口
receive的Packet要创建一个byte数组空间接受

TCP传输：两个端点的建立连接后会有一个传输数据的通道，这通道称为流，而且是建立在网络基础上的流，
称之为socket流。该流中既有读取，也有写入
tcp的两个端点：一个是客户端，一个是服务端。
客户端：对应的对象，Socket
服务端：对应的对象，ServerSocket

TCP客户端：
1，建立tcp的socket服务，最好明确具体的地址和端口。这个对象在创建时，就已经可以对指定ip和端口进行连接(三次握手)。
2，如果连接成功，就意味着通道建立了，socket流就已经产生了。只要获取到socket流中的读取流和写入流即可，只要通过getInputStream和getOutputStream就可以获取两个流对象。
3，关闭资源。

import java.net.;
import java.io.;
//需求：客户端给服务器端发送一个数据。
class TcpClient{
public static void main(String[] args) throws Exception{
Socket s = new Socket(“10.1.31.69”,10002);
OutputStream out = s.getOutputStream();//获取了socket流中的输出流对象。
out.write(“tcp演示，哥们又来了!”.getBytes());
s.close();
}

TCP服务端：
1，创建服务端socket服务，并监听一个端口。
2，服务端为了给客户端提供服务，获取客户端的内容，可以通过accept方法获取连接过来的客户端对象。
3，可以通过获取到的socket对象中的socket流和具体的客户端进行通讯。

class TcpServer{
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket(10002);//建立服务端的socket服务
Socket s = ss.accept();//获取客户端对象
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+"…connected");
// 可以通过获取到的socket对象中的socket流和具体的客户端进行通讯。
InputStream in = s.getInputStream();//读取客户端的数据，使用客户端对象的socket读取流
byte[] buf = new byte[1024];
int len = in.read(buf);
String text = new String(buf,0,len);
System.out.println(text);
// 如果通讯结束，关闭资源。注意：要先关客户端，在关服务端。
s.close();
ss.close();
}
}