Java基础知识梳理

好久没写博客，今天看到草稿箱里一篇躺了快一年的文章，删了又可惜，还是发出来吧

Java基础语法

1、Java语言跨平台实现：依赖于JVM

J2SE J2ME J2EE

2、数据类型

3、Random类

4、Java内存分配图解

5、命名规则

面向对象基础

1、类的定义与使用

定义

使用

2、对象内存图

一个对象的内存图

方法共用的内存图

两个引用指向同一个对象

3、成员变量和局部变量的区别

4、private关键字封装成员变量，get,set方法访问。（get,set方法可自动生成）
5、this关键字的使用：当局部变量隐藏成员变量

常用API

1、String
1.1


1.2 String类的用法
判断

获取

转换

其它

2、StringBuilder

String拼接浪费空间，StringBuilder可以直接追加

StringBuilder类的常用方法：append reverse

注意StringBuilder类与String类是不同的类，需要toString方法转换

3、ArrayList

集合类、泛型

4、FileWriter && FileReader
IO流

FileWriter fw = new FileWriter(''d:\\a.txt'');
fw.write("hello");
fw.flush();
fw.close();

5、BufferedWriter && BufferedReader
IO流


BufferedWriter类newline()方法：

BufferedReader类readline()方法

面向对象

static

代码块

1.局部代码块

2.构造代码块

3.静态代码块

继承

super && this

抽象

抽象方法必须在抽象类中，抽象方法一般出现在子类较多，且需要根据具体子类重写方法的时候。

接口

关系

接口的优点

接口与抽象类的区别

案例分析

匿名对象

final

多态

向上转型和向下转型

权限修饰符

常见规则

内部类

正则表达式

Collection接口（jdk8中接口中的方法可以有方法体，不能被实例化）

add()
clear()
contains()
isEmpty()
remove()
size()
toArray()

public class CollectionDemo2 {
	public static void main(String[] args) {		
		//创建集合对象
		//Collection c = new Collection();//Collection是接口，不能实例化
		Collection c = new ArrayList();//多态，父类引用指向子类对象  
		
		//boolean add(E e)  
		System.out.println(c.add("hello"));//永远可以添加成功，因为ArrayList他允许重复
		System.out.println(c.add("world"));
		
		//void clear()：清空集合
		//c.clear();
		
		//boolean contains(Object o)  :判断集合中是否包含指定元素
		//System.out.println(c.contains("java"));
		
		//boolean isEmpty() :是否为空
		//System.out.println(c.isEmpty());
		
		
		//boolean remove(Object o) :删除元素
		//System.out.println(c.remove("java"));
		
		//int size() :返回集合中的元素个数
		//System.out.println(c.size());
		
		//Object[] toArray()  :将集合转换成一个Object类型的数组
		Object[] objs = c.toArray();
		for (int i = 0; i < objs.length; i++) {
			System.out.println(objs[i]);
		}
		
		
		
		System.out.println(c);
	}
}

迭代器 Iterator

/*
 * 集合的遍历方式：
 * 		1.toArray(),可以把集合转换成数组，然后遍历数组即可
 * 		2.iterator(),可以返回一个迭代器对象，我们可以通过迭代器对象来迭代集合
 * 
 * Iterator：可以用于遍历集合
 * 	E next()  :返回下一个元素
 *  boolean hasNext()  ：判断是否有元素可以获取
 * 
 *  注意：Exception in thread "main" java.util.NoSuchElementException
 *  	使用next方法获取下一个元素，如果没有元素可以获取，则出现NoSuchElementException
	
 */
public class IteratorDemo {
	public static void main(String[] args) {
		//method();
		//创建集合对象
		Collection c = new ArrayList();
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//获取迭代器对象
		Iterator it = c.iterator();
		
		//Object next()  :返回下一个元素
		//boolean hasNext()  ：判断是否有元素可以获取
				
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}



//toArray方式遍历
	private static void method() {
		//创建集合对象
		Collection c = new ArrayList();
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		//获取数组
		Object[] objs = c.toArray();
		//遍历数组
		for (int i = 0; i < objs.length; i++) {
			System.out.println(objs[i]);
		}
	}

并发修改异常

/*
 * 需求：判断集合中是否包含元素java，如果有则添加元素android
 * Exception in thread "main" java.util.ConcurrentModificationException:并发修改异常
 * 迭代器是依赖于集合的，相当于集合的一个副本，当迭代器在操作的时候，如果发现和集合不一样，则抛出异常
 * 
 * 解决方案:
 * 		你就别使用迭代器
 * 		在使用迭代器进行遍历的时候使用迭代器来进行修改
 */
public class IteratorDemo3 {
	public static void main(String[] args) {
		//method();
		
		//创建集合对象
		//Collection c = new ArrayList();
		List c = new ArrayList();
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//我们可以通过遍历来获取集合中的每一个元素，然后进行比较即可
		/*Iterator it = c.iterator();
		while(it.hasNext()) {
			String s = (String)it.next();
			if(s.equals("java")) {
				c.add("android");
			}
		}*/  以上代码块会出现并发修改异常，应该修改迭代器中的内容，让其更新集合
		
		//Iterator没有add方法，我们使用器子接口ListIterator
		ListIterator lit = c.listIterator();
		while(lit.hasNext()) {
			String s = (String)lit.next();
			if(s.equals("java")) {
				lit.add("android");
			}
		}
		
		System.out.println(c);

	}


}

泛型

/*
 * 使用集合存储自定义对象并遍历
 * 由于集合可以存储任意类型的对象，当我们存储了不同类型的对象，就有可能在转换的时候出现类型转换异常，
 * 所以java为了解决这个问题，给我们提供了一种机制，叫做泛型
 * 
 * 泛型：是一种广泛的类型，把明确数据类型的工作提前到了编译时期，借鉴了数组的特点
 * 泛型好处：
 * 			避免了类型转换的问题
 * 			可以减少黄色警告线
 * 			可以简化我们代码的书写
 * 
 * 什么时候可以使用泛型？
 * 		问API，当我们看到<E>，就可以使用泛型了
 * 			
 */
        //创建集合对象
        ArrayList<Student> c = new ArrayList<Student>();
        //遍历集合对象
        Iterator<Student> it = c.iterator();
        while(it.hasNext()) {
        
            Student stu = it.next();
            System.out.println(stu.name);
            
        }

增强for循环

public static void main(String[] args) {
	    //创建集合对象
		Collection<String> c = new ArrayList<String>();
		
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//增强for循环；有代码提示foreach
		for (String string : c) {
			c.add("android");//会出错，并发修改异常，只能修改迭代器对象，不能修改集合对象
			System.out.println(string);
		}
	}

List

/*
 * List:
 * 		有序的（存储和读取的顺序是一致的）
 * 		有整数索引
 * 		允许重复的
 * 
 * List的特有功能：
 * 			void add(int index, E element)  
 * 			E get(int index)  
 * 			E remove(int index)  
 *  		E set(int index, E element)
 *  
 *   增删改查
 *   
 */

接口List实现的常用子类

/*
 * List的常用子类：
 * 		ArrayList
 * 			底层是数组结构，查询快，增删慢
 * 		LinkedList
 * 			底层结构是链表，查询慢，增删快
 * 
 * 如何选择使用不同的集合？
 * 		如果查询多，增删少，则使用ArrayList
 * 		如果查询少，增删多，则使用LinkedList
 * 		如果你不知道使用什么，则使用ArrayList
 * 
 * LinkedList的特有功能：
 * 			void addFirst(E e)  
 * 			void addLast(E e) 
 			E getFirst()  
 			E getLast()  
 			E removeFirst() 
 			E removeLast() 
 * 				
 */


public static void main(String[] args) {
			LinkedList list = new LinkedList();
			list.add("hello");
			list.add("world");
		
			//void addFirst(E e)  :将元素添加到索引为0的位置
 			//void addLast(E e) ：将元素添加到索引为size()-1的位置
			list.addFirst("java");
			list.addLast("android");
			
 			//E getFirst()  :获取索引为0的元素
 			//E getLast()  ：获取索引为size()-1的元素
			//System.out.println(list.getFirst());
			//System.out.println(list.getLast());
			
 			//E removeFirst() :删除索引为0的元素并返回
 			//E removeLast() ：删除索引为size()-1的元素并返回
			System.out.println(list.removeFirst());
			System.out.println(list.removeLast());
			
			
			System.out.println(list);
	}

Set

Collections工具类

试题：Collection和Collections有什么区别？

•  Collection是集合体系的最顶层，包含了集合体系的共性
  

•  Collections是一个工具类，方法都是用于操作Collection
  

static int  binarySearch(List list, Object key) 使用二分查找法查找指定元素在指定列表的索引位置

static void copy(List dest, List src) :是把源列表中的数据覆盖到目标列表

static void fill(List list, Object obj) :使用指定的对象填充指定列表的所有元素

static void reverse(List list)  :反转

static void shuffle(List list): 随机置换

static void  sort(List<T> list) :按照列表中元素的自然顺序进行排序

static void swap(List list, int i, int j) :将指定列表中的两个索引进行位置互换

Map

/*
 * 	Map的常用功能：
 * 		映射功能：
 * 			 	V put(K key, V value) 
 * 		获取功能：
 * 				V get(Object key) 
 * 				int size() 
 * 		判断功能：
 * 				boolean containsKey(Object key) 
 				boolean containsValue(Object value) 
 				boolean isEmpty() 
 
 * 		删除功能：
 * 				void clear()  
 * 				V remove(Object key)  
 * 
 * 		遍历功能：
 * 				Set<Map.Entry<K,V>> entrySet() 
 * 
 * 
 * 			Set<K> keySet() 
 * 			Collection<V> values()   
 * 
 * 	public static void main(String[] args) {
		//创建Map对象
		Map<String,String> map = new HashMap<String,String>();
		//添加映射关系
		map.put("ITCAST001", "张三");
		map.put("ITCAST002", "李四");
		map.put("ITCAST005", "李四");
		
		//Set<K> keySet() : 以Set的形式获返回所有的key
		Set<String> keys = map.keySet();
		for (String key : keys) {
			System.out.println(key);
		}
		System.out.println("-----------");
		
		//Collection<V> values() :
		Collection<String> values = map.values();
		for (String value : values) {
			System.out.println(value);
		}
		
		
	}
 
 * 			
 
 */