JAVA所有的基本类及方法 复习笔记

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.lang.model.type.ArrayType;
import javax.xml.crypto.Data;

import org.omg.CORBA.FloatSeqHelper;
import org.omg.CORBA.PUBLIC_MEMBER;

public class ClassMethod {
public synchronized void hjgj() {

}
public void kkk() {
synchronized (this) {

}
}//用来给对象和方法或者代码块加锁,保护线程安全

@SuppressWarnings("deprecation")
public static void main(String[] args) {

byte A=5;//byte是整数型
byte max=Byte.MAX_VALUE; //Byte最大值
byte min=Byte.MIN_VALUE; //byte最小值
Byte.compare((byte)10, (byte)60);//比较两个 Byte 对象所表示的数值大小
Byte.decode("111");//把字符串转换为(byte)型
Byte.parseByte("12");//把字符串转换为(byte)型
Byte.parseByte("00000101", 2);//将一个字符串以指定的参数转换成byte型
Byte.valueOf(A);//返回表示指定 byte 值的一个 Byte对象
Byte.valueOf("00000011", 2);//返回一个以指定参数的字符串的byte对象


short s = 34;//short是整数型
short smax=Short.MAX_VALUE;//short最大值
short smin=Short.MIN_VALUE;//short最小值
Short.compare((short)155, (short)6555);//比较两个 Short 对象所表示的数值大小
Short.decode("12654");//将 字符串 解码为 （Short）型
Short.parseShort("325");//把字符串转换为(short)型
Short.parseShort("00001111", 2);//将一个字符串以指定的参数转换成short型
Short.valueOf("12355");//返回一个表示该short值的 String 对象
Short.valueOf("0xaf", 16);//返回一个以指定参数的字符串的short对象


int B=10;//int是整数型
int imax=Integer.MAX_VALUE;//integer最大值
int imin=Integer.MIN_VALUE;//integer最小值
Integer.decode("65489");//将 String 解码为 Integer
Integer.parseInt("1566");//把字符串转换为(integer)型
Integer.parseInt("166555", 10);//将一个字符串以指定的参数转换成integer型
Integer.toBinaryString(1666655);//以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式
Integer.toOctalString(1234651);//以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式
Integer.toHexString(15555);//以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式
Integer.valueOf("15544");//返回一个表示该 Integer 值的 String 对象
Integer.valueOf("01000100",2);//返回一个以指定参数的字符串的integer对象


long E=1616;//long是整数型
long bmax=Long.MAX_VALUE;//long型最大值
long bmin=Long.MIN_VALUE;//long型最小值
//long还有与以上整数型相同的方法


float f = 0.2f;//fioat是单精度浮点型
float lmax=Float.MAX_EXPONENT;//返回 float变量可能具有的最大指数
float lmin=Float.MIN_EXPONENT;//返回float变量可能具有的最小指数
float amin=Float.MIN_NORMAL;//保存 float类型数据的最小正标准值的常量
float xnan=Float.NaN;//保存 float类型的非数字 (NaN) 值的常量
float negative=Float.NEGATIVE_INFINITY;//保存返回 float类型的负无穷大值的常量
float positive=Float.POSITIVE_INFINITY;//返回 float类型的正无穷大值的常量
float fsize=Float.SIZE;//用于表示float值的位数
Float.parseFloat("0.546546");//返回一个新的 float值，该值被初始化为用指定 String 表示的值
Float.compare(0.2646f, 0.219f);//比较俩个float型数据大小
float aa=5/3;
Float.isInfinite(aa);//如果指定数的数值是无穷大，则返回 true，否则返回 false
Float.isNaN(161);//如果此 Float 值是一个非数字 (NaN) 值，则返回 true，否则返回 false
Float.toHexString(115);//返回 float 参数的十六进制字符串表示形式
Float.valueOf(543454);// 返回表示指定的 float 值的 Float 实例


double d = 0.8;//double是双精度浮点型
Double.parseDouble("0.25498");//返回一个新的 double值，该值被初始化为用指定 String 表示的值
double wmax=Double.MAX_EXPONENT;//返回 double 变量可能具有的最大指数
double wmin=Double.MIN_EXPONENT;//返回 double 变量可能具有的最小指数
double emin=Double.MIN_NORMAL;//保存 double 类型的最小正标准值的常量
double nan=Double.NaN;//如果此 double值是一个非数字 (NaN) 值，则返回 true，否则返回 false
double nega=Double.NEGATIVE_INFINITY;// 返回 double 类型的负无穷大值的常量
double posi=Double.POSITIVE_INFINITY;// 返回double 类型的正无穷大值的常量
double dsize=Double.SIZE;// 用于表示 double 值的位数
Double.compare(0.1469, 0.26974687);//比较俩个float型数据大小
double qq=5/3;
Double.isInfinite(qq);//如果此 Double 值在数值上为无穷大，则返回 true；否则返回 false
Double.isNaN(2.055856);//如果此 Double 值是非数字（NaN）值，则返回 true；否则返回 false
Double.longBitsToDouble(17845616);//返回对应于给定位表示形式的 double 值
Double.toHexString(0.19165156);//返回 double 参数的十六进制字符串表示形式
Double.valueOf(1.0231351354);// 返回表示指定的 double 值的 Double 实例


String string = new String("abc");//new一个string对象
string.substring(2);// 返回一个新的字符序列，它是此序列的一个子序列
string.equals(string);//将此字符串与指定的对象比较
string.indexOf("555");//  返回指定字符在此字符串中第一次出现处的索引
string.length();//返回此字符串的长度
string.charAt(3);//返回指定索引处的 char 值
string.compareTo("cbcg");//按字典顺序比较两个字符串
string.concat("vcx");//将指定字符串连接到此字符串的结尾
string.compareToIgnoreCase("bvm");//按字典顺序比较两个字符串，不考虑大小写
string.contains("c");// 当且仅当此字符串包含指定的 char 值序列时，返回 true
string.contentEquals("123");//将此字符串与指定的 CharSequence 比较
string.endsWith("vbn");//测试此字符串是否以指定的后缀结束
string.equalsIgnoreCase("gfh");//将此 String 与另一个 String 比较，不考虑大小写
string.getBytes();// 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
char[] m={'m'};
string.getChars(2, 3, m, 1);// 将字符从此字符串复制到目标字符数组
string.hashCode();//返回此字符串的哈希码
string.intern();//返回字符串对象的规范化表示形式
string.isEmpty();//当且仅当 length() 为 0 时返回 true
string.lastIndexOf("vcvcn");// 返回指定字符在此字符串中最后一次出现处的索引
string.matches("nvmxc");//告知此字符串是否匹配给定的正则表达式
string.notify();//唤醒
string.notifyAll();//唤醒全部
string.regionMatches(1, "zxc", 3, 2);//测试两个字符串区域是否相等
string.replace("a", "m");//返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的
string.replaceAll("abc","mnb" );//使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
string.replaceFirst("mnh", "khg");//使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串
string.split("asd");//  根据给定正则表达式的匹配拆分此字符串
string.toCharArray();//将此字符串转换为一个新的字符数组
string.toUpperCase();//使用给定 Locale 的规则将此 String 中的所有字符都转换为小写
string.toUpperCase();//使用给定 Locale 的规则将此 String 中的所有字符都转换为大写
string.copyValueOf(m);//返回指定数组中表示该字符序列的 String
string.format("hdf", args);//使用指定的格式字符串和参数返回一个格式化字符串
string.valueOf("x");//返回 char 参数的字符串表示形式
string.trim();//去掉首位空格
try {
string.wait();//等待
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}


boolean b = true;//or false
Boolean.parseBoolean("true");//将字符串参数解析为 boolean 值
Boolean.compare(true,false );//将此 Boolean 实例与其他实例进行比较
Boolean.getBoolean("565");//当且仅当以参数命名的系统属性存在，且等于 "true" 字符串时，才返回 true
Boolean.toString(false);//返回表示该布尔值的 String 对象
Boolean.valueOf(true);//返回一个表示指定 boolean 值的 Boolean 实例


int[] arr = new int[10];
int[] array = {1,2,3,4,5,6,7,8,9,10};

char[] arr6=new char[3];
char[] array6={'v'};


String[] arr1=new String[20];
String[] array1={"256265","4156"};

byte[] arr2=new byte[122];
byte[] array2={15,16};

long[] arr5=new long[10];
long[] array5={1232,456,456};

short[] arr3=new short[5];
short[] array3={123,523};

Object[] arr4=new Object[20];
Object[] array4={arr,arr1};
Arrays.asList(arr);//返回一个受指定数组支持的固定大小的列表
Arrays.binarySearch(arr, 1);//使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值
Arrays.copyOf(arr2, 2);//复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度
Arrays.copyOfRange(arr, 1, 2);//将指定数组的指定范围复制到一个新数组
Arrays.deepEquals(arr4, array4);//如果两个指定数组彼此是深层相等 的，则返回 true
Arrays.fill(arr2, (byte)4);//将指定的 byte 值分配给指定 byte 节型数组的每个元素
Arrays.sort(arr);//对指定的 byte 型数组按数字升序进行排序
Arrays.toString(arr5);//返回指定数组内容的字符串表示形式

//如何使用循环遍历数组
for (int i = 0; i < 100; i++) {
if (i%2==0) {
System.out.println("2的倍数："+i);
}else if (i%3==0) {
System.out.println("3的倍数："+i);
}else if (i%5==0) {
System.out.println("5的倍数："+i);
}else if (i%7==0) {
System.out.println("7的倍数："+i);
}else {
continue;
}
    }

int intarray[]={1,2,3,4,5,6,7,8,9,10};
int i=0;
while (i<10) {
System.out.println(intarray[i]);
i++;
}

do {
System.out.println(intarray[i]);
i++;
} while (i<10);

int num=1;
switch (num) {
case 1:
System.out.println("1");
break;
default:
System.out.println("赋值的数不是1");
break;
}
//两个跳转语句
// break;//结束此循环
// continue;//重新开始循环

//修饰符
// statis//表示静态的意思
// this//当前对象的意思
// super//调用父类方法
// final//可以修饰类。方法。属性。表示不可被继承。不能被重写，定义常量
//
//访问权限
List<String> list=new ArrayList<String>();
list.add("dasf");//添加元素
list.add(2, "nbh");//在指定位置添加元素
list.addAll(new ArrayList<String>());//添加同类型元素集合
String str1=list.get(2);//获取指定位置的元素
int iSize=list.size();//集合有多少个元素
boolean isCon=list.contains("nj");//如果列表包含指定的元素，则返回 true
boolean isConall=list.containsAll(new ArrayList<String>());//如果列表包含指定的元素集合，则返回 true
String[] strArr=(String[]) list.toArray();//转成数组
list.remove("nk");//删除指定元素，若成功返回true
list.remove(3);//删除指定位置元素，若成功返回true
list.removeAll(new ArrayList<String>());//删除元素集合，若成功返回true
list.set(2, "cac");//设置指定位置元素
boolean isEmpty=list.isEmpty();//是否为空
list.clear();//清空

StringBuffer n=new StringBuffer();
n.append(new StringBuffer("nj"));//追加其他字符串缓存
n.append("da");//追加一个字符串
int iLen=n.length();//字符串长度
n.delete(5, 6);//删除指定范围的元素
n.substring(1);//截取指定位置到末尾的元素返回新的字符串
n.substring(2, 3);//截取指定范围的元素返回成新的字符串
String str=n.toString();//返回缓存中的字符串

Map<Integer,String> map=new HashMap<Integer,String>();
map.get(5);//获取指定KEY映射的值
map.put(5, "5");//添加指定KEY与VALUE的键值对
map.putAll(new HashMap<Integer,String>());//从指定映射中将所有映射关系复制到此映射中
map.containsKey(5);//是否包含指定KEY
map.remove(5);//删除指定KEY
map.clear();//清空所有键值对
map.containsValue("5");//是否包含VALUE
map.size();//返回键值对数
map.isEmpty();//是否为空
List<String> lVals=(List<String>) map.values();//返回值集
Set<Integer> sKeys=map.keySet();//返回键集

Set<Entry<Integer, String>> entry=map.entrySet();
for (Entry<Integer, String> en : entry) {
System.out.println(en.getValue());
System.out.println(en.getKey());
}

Set<String> set=new HashSet<>();
set.add("jsjs");//添加指定元素
set.addAll(new HashSet<String>());//添加元素集合
set.remove("jjj");//删除指定元素
set.removeAll(new HashSet<>());//删除指定集合
set.contains("hdh");//是否包含指定元素
set.isEmpty();//判断是否为空
Iterator<String> iterator=set.iterator();//生成一个迭代器
iterator.next();//获取下一个元素
iterator.hasNext();//还有没有下一个元素
set.clear();//清空set中所有元素
set.size();//返回set中的元素数

// //继承
// extends//子类能继承父类的属性，方法
// //方法的重写
// @Override //子类继承父类，可以重写父类方法，实现接口时必须重写接口的方法
// //接口怎么实现
// implements //实现接口，可以直接使用接口的方法
// //抽象类与接口的区别
// abstract class 与 interface //抽像类即可以既有方法，也可以有方法和方法体，接口只有方法

Thread t = new Thread() ;//thread是类，只能被单继承，
t.start();//运行Thread方法
t.interrupt();//中断线程
t.isAlive();//是否存活
t.getName();//获取线程的名字
t.isInterrupted();//判断是否被中断
t.run();//线程的运行方法
t.notify();//唤醒线程
try {
t.wait();//让线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
t.notifyAll();//唤醒全部线程
t.stop();//终止线程
try {
t.sleep(2000, 123);//睡眠指定时间
} catch (InterruptedException e1) {
e1.printStackTrace();
}
try {
Thread.sleep(6000, 5621);//睡眠指定时间
} catch (InterruptedException e) {
e.printStackTrace();
}

// //实现方式
// Runnable//runnable是接口，可以被多次实现

//多线程的应用场景 例：火车站售票处，

//线程的五种状态：   创建状态，就绪状态，运行状态，阻塞状态，终止状态

// synchronized(this){
//
// }//用来给对象和方法或者代码块加锁,保护线程安全



//I/O
File file=new File("D:/IDK");
file.exists();//文件是否存在
file.mkdirs();//创建文件组
file.mkdir();//创建文件
try {
file.createNewFile();//创建新的文件
} catch (IOException e) {
e.printStackTrace();
}
file.getAbsolutePath();//返回绝对路径
file.getPath();//返回路径
file.isAbsolute();//是否是文件绝对路径名
file.delete();//删除此抽象路径名表示的文件或目录
file.deleteOnExit();//退出时删除此抽象路径名表示的文件或目录
file.isDirectory();//是否是目录
file.isFile();//是否是文件
file.canRead();//能否可读
file.canWrite();//能否修改
file.listFiles();//列出文件
file.getName();//返回文件名
file.getParentFile();//返回父文件实例
file.getParent();//返回父文件路径
file.isHidden();//是否是隐藏文件
file.length();//返回文件字节
try {
FileInputStream FIS=new FileInputStream(file);//文件输入流
} catch (FileNotFoundException e) {
e.printStackTrace();
}


try {
InputStream is=new FileInputStream(file);//输入流，抽象类
} catch (FileNotFoundException e) {
e.printStackTrace();
}
InputStream IPS=new InputStream() {
@Override
public int read() throws IOException {
return 0;
}
};
try {
IPS.read();//读取数据的下一个字节
IPS.reset();//将此流重新定义到最后一次调用MARK方法时的位置
IPS.close();//关闭此输入流并释放与该流关联的所有系统资源

} catch (IOException e) {
e.printStackTrace();
}
int readlimit = 0;
IPS.mark(readlimit);//在此输入流中标记当前的位置



OutputStream OPS=new OutputStream() {
@Override
public void write(int b) throws IOException {
}
};//输出流,抽象类
try {
OPS.write(2);//将制定的字节写入此输出流
OPS.close();//关闭此输出流并释放与此流有关的所有系统资源
OPS.flush();//刷新此输出流并强制写出所有缓冲的输出字节
} catch (IOException e) {
e.printStackTrace();
}


ObjectInputStream OIS;//对象输入流
try {
OIS = new ObjectInputStream(IPS);
OIS.readObject();//读入（对象）数据
OIS.readInt();//读入（int）数据
OIS.defaultReadObject();//读入默认（对象）数据
OIS.close();//关闭此输入流并释放与该流关联的所有系统资源
OIS.readBoolean();//读取一个boolean
OIS.available();//返回可以不受阻塞地读取的字节数
OIS.readFully(arr2);;//读取（byte）字节，同时阻塞直到读取所有字节
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}


ObjectOutputStream OOS;
try {
OOS = new ObjectOutputStream(OPS);
OOS.writeObject(str1);//写出指定（对象）数据
OOS.close();//关闭此输出流并释放与流关联的所有系统资源
OOS.putFields();//获取用于缓冲写入流中的持久存储字段的对象
OOS.reset();//将此流重新定义到最后一次调用MARK方法时的位置
OOS.writeBytes(str);// 以字节序列形式写入一个 String
OOS.defaultWriteObject();//写出默认（对象）数据
OOS.writeInt(i);//写入指定的（int）数据
OOS.flush();//刷新该流的缓冲
} catch (IOException e) {
e.printStackTrace();
}//对象输出流


ByteArrayInputStream BIS=new ByteArrayInputStream(arr2);//字节数组输入流


ByteArrayOutputStream BOS=new ByteArrayOutputStream();//字节数组输出流
BOS.toByteArray();//返回（byte）数组
DataInputStream DIS=new DataInputStream(IPS);//数据输入流


DataOutputStream DOS=new DataOutputStream(OPS);//数据输出流
try {
DOS.writeInt(2);//写出指定(int)数据
} catch (IOException e) {
e.printStackTrace();
}
DOS.size();//返回目前为止写入此数据输出流的字节数


FileInputStream FIS1;//文件输入流
try {
FIS1 = new FileInputStream(file);
FIS1.getFD();//该文件系统正被此 FileInputStream 使用,返回表示到文件系统中实际文件的连接的 FileDescriptor对象
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
}


FileOutputStream FOS;
try {
FOS = new FileOutputStream(file);//文件输出流
FOS.getFD();//返回与此流有关的文件描述符
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
}


Reader R=new Reader() {
@Override
public int read(char[] cbuf, int off, int len) throws IOException {
return 0;
}
@Override
public void close() throws IOException {
}
};


Writer W=new Writer() {
@Override
public void write(char[] cbuf, int off, int len) throws IOException {
}
@Override
public void flush() throws IOException {
}
@Override
public void close() throws IOException {
}
};


InputStreamReader ISR=new InputStreamReader(IPS); //输入流reader
ISR.getEncoding();//返回此流使用的字符编码的名称


OutputStreamWriter OSW=new OutputStreamWriter(OPS);//输出流writer
OSW.getEncoding();//返回此流使用的字符编码的名称
try {
OSW.append((char) 'n');//将指定字符添加到此 writer
} catch (IOException e) {
e.printStackTrace();
}
try {
int end = 0;
CharSequence csq = null;
int start = 0;
OSW.append(csq, start, end);//将指定字符序列的子序列添加到此 writer.Appendable
} catch (IOException e) {
e.printStackTrace();
}


BufferedReader BR=new BufferedReader(ISR);//带缓冲的reader
try {
BR.readLine();//读取一个文本行
BR.ready();//判断此流是否已准备好被读取
BR.skip((long)5);//跳过字符
BR.ready();//判断是否准备被阅读
int readAheadLimit = 0;
BR.mark(readAheadLimit);//标记流中的当前位置
BR.markSupported();//判断此流是否支持 mark() 操作
} catch (IOException e) {
e.printStackTrace();
}


BufferedWriter BW=new BufferedWriter(OSW);//带缓冲的writer
try {
BW.newLine();//写入一个行分隔符
} catch (IOException e) {
e.printStackTrace();
}
}

}