java重点笔记

一、基础

HelloWorld.java 脚步运行

文件名：HelloWorld.java

文件名与class名必须一致

代码编写

public class HelloWorld{
	public static void main(String[] args)
	{
		System.out.println("Hello World!");
	}
}

编译java文件
命令：javac Hello.java

执行class文件
java Hello

---

Scanner 类人机交互

Scanner s =new Scanner（System.in）； //用于接收键盘数据

s.hasNext() //判断是否字符串
s.hasNextLine() //判断是否字符串
s.hasNextInt() //判断是否整数
s.hasNextDouble() //判断是否double
s.hasNextFloat() //判断是否float类型

s.nextLine() //接收字符串，获取回车之前的所有字符
s.nextInt() //接收整数
s.nextDouble() //接收double
s.nextFloat() //接收float类型

语法：

	public static void main(String[] args)
	{
		Scanner scan =new Scanner(System.in);	//定义键盘接收对象
		
		...........逻辑编码

		scan.close();	//关闭对象
	}

代码：

import java.util.Scanner

public class Demo{
	public static void main(String[] args)
	{
		Scanner scan =new Scanner(System.in);	//定义键盘接收对象
		
		System.out.println("请输入一个数字：");
		String str=scan.hasNext();	//将输入的字符串赋值给str
		
		scan.close();
	}
}

---

for循环及for数组增强

for(int i=0;i<100;i++)
{
	 循环体......
}

for 组数增强：

无法获取数组的下标

int[] arry={10,20,30,40,50}
for(int x :arry)
{
	System.out.println(x);
}

---

数组

Array数组

特点：

1、类型一致
2、长度不可变
3、数组长度array.length

方法：

给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

数组声明：

int[] arry=new int[10];

数组声明并直接赋值：

int[] arry={1,2,3,4,5};

---

ArrayList 数组

Array 与ArrayList的区别

Array（[]）：最高效；但是其容量固定且无法动态改变；
ArrayList： 容量可动态增长；但牺牲效率；

方法：

add() 将元素插入到指定位置的 arraylist 中
addAll() 添加集合中的所有元素到 arraylist 中
clear() 删除 arraylist 中的所有元素
clone() 复制一份 arraylist
contains() 判断元素是否在 arraylist
get() 通过索引值获取 arraylist 中的元素
indexOf() 返回 arraylist 中元素的索引值
removeAll() 删除存在于指定集合中的 arraylist 里的所有元素
remove() 删除 arraylist 里的单个元素
size() 返回 arraylist 里元素数量
isEmpty() 判断 arraylist 是否为空
subList() 截取部分 arraylist 的元素
set() 替换 arraylist 中指定索引的元素
sort() 对 arraylist 元素进行排序
toArray() 将 arraylist 转换为数组
toString() 将 arraylist 转换为字符串
ensureCapacity() 设置指定容量大小的 arraylist
lastIndexOf() 返回指定元素在 arraylist 中最后一次出现的位置
retainAll() 保留 arraylist 中在指定集合中也存在的那些元素
containsAll() 查看 arraylist 是否包含指定集合中的所有元素
trimToSize() 将 arraylist 中的容量调整为数组中的元素个数
removeRange() 删除 arraylist 中指定索引之间存在的元素
replaceAll() 将给定的操作内容替换掉数组中每一个元素
removeIf() 删除所有满足特定条件的 arraylist 元素
forEach() 遍历 arraylist 中每一个元素并执行特定操作

例子：

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites);
    }
}

---

Arrays类

int[] array={1,8,99,22};
Arrays.toString(array);	//转成字符串
Arrays.sort(array);	//数组排序

二、进阶

构造方法

*构造方法特点：

• 函数名与class类名必须一致
• 没有返回值，连void也不行
• 定义了有参构造，无参构造就必须定义

public class User{
	String name;
	
    public User(){	//无法构造方法
    }
 
    public User(String nm){	// 这个构造器仅有一个参数：name
        this.name=nm;	//对象初始化时，给属性赋值
    }
}

---

继承：关键字extends

this() 与super（）、this与super 的区别

this() //调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
supper () //调用父类中的某一个构造函数（必须为构造函数中的第一条语句）

super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）
this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）

---

interface 接口

• interface 实际就是抽象类；’
• interface 的方法没有方法体；
• interface 的实现类格式规范为 接口名+Impl
• impl实现类使用 implements可实现多个接口
• 实现类必须要重写接口的所有方法

---

Exception 异常与 ERROR

Java API 中的异常类分为：错误ERROR、异常Exception
Java 中所有异常的父类是 java.lang.Throwable
异常处理关键字：try catch finally、throw、throws

throw与throws的区别:

• throws出现在方法的声明中，表示该方法可能会抛出的异常，允许throws后面跟着多个异常类型
• throw出现在方法体中，用于抛出异常。当方法在执行过程中遇到异常情况时，将异常信息封装为异常对象，然后throw。

捕获异常try catch

抛出异常throw、throws

常见异常类

public void test(int a，int b) throws Exception1，Exception3 {
           try{
                 //......

           }catch(Exception1 e){
              throw e;
           }catch(Exception2 e){
              System.out.println("自己打印提示，不抛出");
           }
           if(a!=b)
              throw new  Exception3("自定义异常");
}

泛型&集合

泛型

泛型类：

格式：修饰符 class 类名<类型> { }

public class Generic<T> {
	private T t;

	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}
}

泛型方法：

格式：修饰符 <类型> 返回值类型 方法名(类型 变量名) { }

public class Generic {
	public <T> void show(T t) {
		System.out.println(t);
	}
}

泛型接口：

格式：修饰符 interface 接口名<类型> { }

interface Generic<T> {
	void show(T t);
}

public class GenericImpl<T> implements Generic<T> {
	@Override
	public void show(T t) {
		System.out.println(t);
	}
}

类型通配符：

类型通配符：<?>
    List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型    
类型通配符上限：<? extends 类型>
    List<? extends Number>：它表示的类型是Number或者其子类型    
类型通配符下限：<? super 类型>
    List<? super Number>：它表示的类型是Number或者其父类型 

集合体系：

Collection接口

子接口特点：

1. List接口：按照顺序存取，元素可以重复，有索引，可使用迭代器、增强for循环、普通for循环遍历
2. Set接口：不按照顺序存取，元素不可以重复，没有索引，可使用迭代器、增强for循环遍历（了解）

// 创建集合
		Collection<String> collection = new ArrayList<String>();

通用方法：

方法	描述	返回值
collection.add(“内容”)	添加元素	无
collection.remove(“内容”）	移除元素	无
collection.contains(“内容”)	判断元素是否包含内容	boolean
collection.isEmpty()	判断集合是否为空	boolean
collection.size()	取集合元素个数	int
collection.clear()	清空集合所有元素	无
collection.addAll(集合对象)	添加其他集合	无

增强for循环遍历：

for (String s : collection) {
			System.out.println(s);
		}

添加另外集合元素：

Collection<String> c = new ArrayList<String>();
		c.add("小可爱");
		c.add("大可爱");
		collection.addAll(c);
		System.out.println(collection.toString());

List接口

子类特点：

1. ArrayList集合：底层是数组结构实现，查询快、增删慢
2. LinkedList集合：底层是链表结构实现，查询慢、增删快（了解）

// 创建集合
		List<String> list= new ArrayList<String>();

通用方法：集成Collection接口

Map接口

// 创建集合
		Map<String, String> map = new HashMap<String, String>();

通用方法：

方法	描述	返回值
map.put(key，value)	添加元素	无
map.remove(key）	移除元素	无
map.get(key）	获取key的值	返回key对应的值
map.containsKey(key)	判断集合是否包含key	boolean
map.containsKey(value)	判断集合是否包含value	boolean
map.isEmpty()	判断集合是否为空	boolean
map.size()	取集合元素个数	int
map.clear()	清空集合所有元素	无
map.putAll(集合对象)	添加其他集合	无
map.keySet()	获取所有key	Set集合
map.values()	获取所有值	Collection集合
map.entrySet()	获取所有键值对对象的集合	Set类型的Map

		// 创建集合
		Map<String, String> map = new HashMap<String, String>();

		// 获取所有键的集合
		Set<String> keySet = map.keySet();
		
		// 获取所有值的集合
		Collection<String> values = map.values();		

		// 获取所有键值对对象的集合
		Set<Entry<String, String>> entrySet = map.entrySet();
		}

增强遍历：

		// 增强for遍历所有key
		for (String key : keySet) {
			System.out.println(key);
		}
		
		// 增强for遍历所有value
		for (String value : values) {
			System.out.println(value);
		}
		
		// 增强for遍历所有键值对对象
		for (Entry<String, String> entry : entrySet) {
			String key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key + ":" + value);
		}

文件&IO流

File类

File类主要用于文件和目录的创建、文件的查找和文件的删除等。File对象是磁盘中实际存在的文件或文件目录

构造方法：(初始化对象)

方法	描述
new File(String pathname)	通过给定的路径名字符串创建新的File实例
new File(String parent, String child)	通过父路径名字符串、子路径名字符串创建新的File实例
new File(File parent, String child)	通过父路径对象、子路径名字符串创建新的File实例

创建方法：（创建文件或目录）

方法	描述
createNewFile()	当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
mkdir()	创建由此抽象路径名命名的单级目录
mkdirs()	创建由此抽象路径名命名的多级目录

判断功能：

方法	描述
isDirectory()	此抽象路径名表示的File是否为目录
isFile()	此抽象路径名表示的File是否为文件
exists()	此抽象路径名表示的File是否存在

获取功能：

方法	描述
getAbsolutePath()	返回此抽象路径名的绝对路径名字符串
getPath()	将此抽象路径名转换为路径名字符串
getName()	返回由此抽象路径名表示的文件或目录的名称
list()	返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
listFiles()	返回此抽象路径名表示的目录中的文件和目录的File对象数组

 //创建File目录对象
        File file=new File("D:\\java");


        if (!file.exists()){//判断File目录对象是否存在
            file.mkdirs();  //创建该目录
            if (file.isDirectory()){//判断File对象是否是目录
                //创建File文件对象(在制定目录下)
                File txtFile =new File(file,"a.txt");
                if (!txtFile.exists()){//判断文件是否存在
                    if (txtFile.isFile()){//判断是否是文件
                        //创建该文件
                        txtFile.createNewFile();
                    }
                }
            }
        }

IO流

1. 如果操作的是纯文本文件，优先使用字符流
2. 如果操作的是图片、视频、音频、应用等二进制文件，优先使用字节流
3. 如果不确定文件类型，优先使用字节流，字节流是万能的流

字节流

字节流读取、写入：

	// 基本字节流一次读写一个字节
	public static void method1() throws IOException {
		//创建输入流对象
		FileInputStream fis = new FileInputStream("sFolder\\demo.txt");
		//创建输出流对象
		FileOutputStream fos = new FileOutputStream("dFolder\\demo.txt");

		int by;
		while ((by = fis.read()) != -1) {
			fos.write(by);
		}

		fos.close();
		fis.close();
	}

	// 基本字节流一次读写一个字节数组
	public static void method2() throws IOException {
		FileInputStream fis = new FileInputStream("sFolder\\demo.txt");
		FileOutputStream fos = new FileOutputStream("dFolder\\demo.txt");

		byte[] bys = new byte[1024];	//定义字节数组
		int len;
		while ((len = fis.read(bys)) != -1) {
			fos.write(bys, 0, len);
		}

		fos.close();
		fis.close();
	}

字符流

基本字符流InputStreamReader读、OutputStreamWrite写：

// 基本字符流一次读写一个字符
	public static void method1() throws IOException {
		//创建输入流
		InputStreamReader isr = new InputStreamReader(new FileInputStream("sFolder\\demo.txt"));
		//创建输出流
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("dFolder\\demo.txt"));

		int ch;
		while ((ch = isr.read()) != -1) {
			osw.write(ch);
		}

		osw.close();
		isr.close();
	}

// 基本字符流一次读写一个字符数组
	public static void method2() throws IOException {
		InputStreamReader isr = new InputStreamReader(new FileInputStream("sFolder\\demo.txt"));
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("dFolder\\demo.txt"));

		char[] chs = new char[1024];	//定义字符数组
		int len;
		while ((len = isr.read(chs)) != -1) {
			osw.write(chs, 0, len);
		}

		osw.close();
		isr.close();
	}

文件字符流FileReader读、FileWrite写：

// 文件字符流一次读写一个字符
	public static void method3() throws IOException {
		FileReader fr = new FileReader("sFolder\\demo.txt");
		FileWriter fw = new FileWriter("dFolder\\demo.txt");

		int ch;
		while ((ch = fr.read()) != -1) {
			fw.write(ch);
		}

		fw.close();
		fr.close();
	}

	// 文件字符流一次读写一个字符数组
	public static void method4() throws IOException {
		FileReader fr = new FileReader("sFolder\\demo.txt");
		FileWriter fw = new FileWriter("dFolder\\demo.txt");

		char[] chs = new char[1024];
		int len;
		while ((len = fr.read(chs)) != -1) {
			fw.write(chs, 0, len);
		}

		fw.close();
		fr.close();
	}

多线程