第四周笔记

前言：

最近的节奏越来越快了，上一周一周的时间就讲了四个大内容，分别是常用类、集合、异常和多线程。现在让我们来依次回顾一下吧。上半部

常用类：

• 内部类
• object类
• 包装类
• String类(重点)

内部类

1.成员内部类 2.静态内部类 3.局部内部类4.匿名内部类

1.2 什么是内部类

概念：在一个类的内部再定义一个完整的类。类中类
特点：编译之后可生成独立的字节码文件。

• 编译之后可生成独立的字节码文件。
• 内部类可直接访问外部类的私有成员，而不破坏封装。
• 可为外部类提供必要的内部功能组件。

演示：

public class Outer {
	//实例变量
	private String name="张三";
	private int age=20;
	
	//内部类
	class Inner{
		private String address="北京";
		private String phone="110";
		//
		private String name="李四";
		
		//private static final String country="中国";
		//方法
		public void show() {
			//打印外部类的属性，内部类属性和外部类的属性名字相同Outer.this
			System.out.println(Outer.this.name);
			System.out.println(Outer.this.age);
			//打印内部类中的属性
			System.out.println(this.address);
			System.out.println(this.phone);
		}
	}
	
}

定义测试类

public class TestOuter {
	public static void main(String[] args) {
		//1创建外部类对象
//		Outer outer=new Outer();
//		//2创建内部类对象
//		Inner inner=outer.new Inner();
		
		//3一步到位
		Inner inner=new Outer().new Inner();
		inner.show();
	}
}

1.4 静态内部类

1.不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
2.只能直接访问外部类的静态成员（实例成员需实例化外部类对象）。
Outer.Inner inner = new Outer.Inner();
Outer.Inner.show();

public class Outer {
	private String name="xxx";
	private int age=18;
	
	//静态内部类：和外部类相同
	static class Inner{
		private String address="上海";
		private String phone="111";
		//静态成员
		private static int count=1000;
		
		public void show() {
			//调用外部类的属性呢
			//1先创建外部类对象
			Outer outer=new Outer();
			//2调用外部类对象的属性
			System.out.println(outer.name);
			System.out.println(outer.age);
			//调用静态内部类的属性和方法
			System.out.println(address);
			System.out.println(phone);
			//调用静态内部类的静态属性
			System.out.println(Inner.count);
		}
	}
}

1.5 局部内部类

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
• 限制类的使用范围。

public class Outer {
	private String name="刘德华";
	private int age=35;
	
	public  void show(final int i) {
		//定义局部变量
		String address="深圳";
		//局部内部类 :注意不能加任何访问修饰符
		class Inner{
			//局部内部类的属性
			private String phone="15588888888";
			private String email="liudehua@qq.com";
			//private final static int count=2000;
			
			public void show2() {
				//访问外部类的属性
				System.out.println(Outer.this.name);
				System.out.println(Outer.this.age);
				//访问内部类的属性
				System.out.println(this.phone);
				System.out.println(this.email);
				//访问局部变量,jdk1.7要求：变量必须是常量 final，jdk1.8 自动添加final
				System.out.println("深圳");
				System.out.println(i);
			}	
		}
		//创建局部内部类对象
		Inner inner=new Inner();
		inner.show2();
		
	}
}

1.6 匿名内部类(重点)

1.没有类名的局部内部类（一切特征都与局部内部类相同）。
2.必须继承一个父类或者实现一个接口。
3.定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
4.优点：减少代码量。

自我理解：在使用接口这一块时，不需要再定义一个新的类去实现接口，直接在类的内部通过匿名内部类进行定义即可。

下面是代码实现。

public class TestUsb {
	public static void main(String[] args) {
	//使用匿名内部类
	Usb usb=new Usb() {	
			@Override
			public void service() {
				System.out.println("连接电脑成功，风扇开始工作了....");
				
			}
		};
		usb.service();
	}
}
}

假如不使用匿名内部类：class Fan implements Usb{ @Override public void service() { System.out.println("连接电脑成功，风扇开始工作了...."); } }

objec 类
何为objec类

• 超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
• 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
• Object类中所定义的方法，是所有对象都具备的方法。
• Object类型可以存储任何对象。
• 作为参数，可接受任何对象。
• 作为返回值，可返回任何对象。

常用方法：

• getClass()

返回引用中存储的实际对象类型.
应用：通常用于判断两个引用中实际存储对象类型是否一致。

• hashCode()方法

返回该对象的十进制的哈希码值。
哈希码并不唯一，可保证相同对象返回相同哈希码，尽量保证不同对象返回不同哈希码。

• toString()方法

返回该对象的字符串表示（表现形式）。
可以根据程序需求覆盖该方法，如：展示对象各个属性值。

• equals()方法

默认实现为(this == obj)，比较两个对象地址是否相同。可进行覆盖，比较两个对象的内容是否相同。
equal重写步骤：
1.比较两个引用是否指向同一个对象。2.判断obj是否为null。3.判断两个引用指向的实际对象类型是否一致。4.强制类型转换5.依次比较各个属性值是否相同。

finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
垃圾对象：没有有效引用指向此对象时，为垃圾对象。
垃圾回收： 由GC销毁垃圾对象，释放数据存储空间。
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
手动回收机制：使用System.gc(); 通知JVM执行垃圾回收。

public class TestFinalize {
	public static void main(String[] args) {
//		Student s1=new Student("aaa", 20);
//		Student s2=new Student("bbb", 20);
//		Student s3=new Student("ccc", 20);
//		Student s4=new Student("ddd", 20);
//		Student s5=new Student("eee", 20);
		new Student("aaa", 20);
		new Student("bbb", 20);
		new Student("ccc", 20);
		new Student("ddd", 20);
		new Student("eee", 20);
		//回收垃圾
		System.gc();
		System.out.println("回收垃圾");
		
	}
}

包装类：

将基本数据类型转为对应的数据类型。包装类的默认值是null。

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

• 装箱

类型转换:装箱,基本类型转成引用类型的过程

装箱实例

int num1=18;
		//使用Integer类创建对象
		Integer integer1=new Integer(num1);
		Integer integer2=Integer.valueOf(num1);
		System.out.println("装箱");
		System.out.println(integer1);
		System.out.println(integer2);

• 拆箱

类型转型:拆箱,引用类型转成基本类型

拆箱实例

Integer integer3=new Integer(100);
		int num2=integer3.intValue();
		System.out.println("拆箱");
		System.out.println(num2);

String类【重点】

描述：

字符串字面值是常量，创建之后不可改变。
常用创建方式：
String str1 = “Hello”; String str2 = new String(“World”);

常用方法：

//字符串方法的使用
1、length();返回字符串的长度
2、charAt(int index);返回某个位置的字符
3、contains(String str);判断是否包含某个子字符串`
字符串方法的使用
4、toCharArray();返回字符串对应的数组
5、indexOf();返回子字符串首次出现的位置
6、lastIndexOf();返回字符串最后一次出现的位置
7、trim();去掉字符串前后的空格
8、toUpperCase();//把小写转成大写 toLowerCase();把大写转成小写
9、endWith(str);判断是否已str结尾,startWith(str);判断是否已str开头
10、replace(char old,char new); 用新的字符或字符串替换旧的字符或字符串
11、split();对字符串进行拆分

1什么是字符串常量池,2字符串不可变是什么意思

字符串常量池，用于减少创建内存时的开销，比如new一个对象
字符串

• 字符串常用方法

subString :在字符串中截取一个字符串

1、length();返回字符串的长度
2、charAt(int index);返回某个位置的字符
3、contains(String str);判断是否包含某个子字符串

-String content="java是世界上最好的java编程语言,java真香";
		System.out.println(content.length());
		System.out.println(content.charAt(content.length()-1));
		System.out.println(content.contains("java"));
		System.out.println(content.contains("php"));

4、toCharArray();返回字符串对应的数组

System.out.println(Arrays.toString(content.toCharArray()));

5、indexOf();返回子字符串首次出现的位置

System.out.println(content.indexOf("java"));

6、lastIndexOf();返回字符串最后一次出现的位置

System.out.println(content.lastIndexOf("java"));

7.split();对字符串进行拆分

String say="java is the best   programing language,java xiang";
		String[] arr=say.split("[ ,]+");

• 可变字符串

• 概念：可在内存中创建可变的缓冲空间，存储频繁改变的字符串。

运行速度
StringBuider>srtingBuffer>string
StringBuider和StringBuffer的区别就是线程安全的区别。这两个类的方法和属性完全一致。

• 常用方法：
  1 append();追加，即在字符串后面追加字符串。

StringBuilder sb=new StringBuilder();
sb.append("java世界第一");

2.insert（）方法
将指定的字符串插入此序列中

sb.insert(0, "我在最前面");
		System.out.println(sb.toString());

日期类（Date、calendar）

现在常用的都是日历calendar类
常用方法：

集合（重点）

• 概念：
  对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。
  那我在想：之前那个吃货联盟的题目用来做集合来做是不是更加简单一些？
• 集合和数组的区别：
  1.数组长度固定，集合长度不固定。
  2.数组可以存储基本类型和引用类型，集合只能存储引用类型。

List接口和实现类

• List接口的特点：
  有序、有下标、元素可以重复。
• 常用方法：

案例演示：

public class TestList {
	public static void main(String[] args) {
		//先创建集合对象
		List list=new ArrayList();
		//1添加元素
		list.add("苹果");
		list.add("小米");
		list.add(0, "华为");
		System.out.println("元素个数:"+list.size());
		System.out.println(list.toString());
		//2删除元素
		//list.remove("苹果");
//		list.remove(0);
//		System.out.println("删除之后:"+list.size());
//		System.out.println(list.toString());
		//3遍历
		//3.1使用for遍历
		System.out.println("-----3.1使用for遍历-----");
		for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));
		}
		//3.2使用增强for
		System.out.println("-----3.2使用增强for-----");
		for (Object object : list) {
			System.out.println(object);
		}
		//3.3使用迭代器
		Iterator it=list.iterator();
		System.out.println("-----3.3使用迭代器-----");
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//3.4使用列表迭代器 ,和Iterator的区别，ListIterator可以向前或向后遍历，添加、删除、修改元素
		ListIterator lit=list.listIterator();
		System.out.println("------使用列表迭代器从前往后-------");
		while(lit.hasNext()) {
			System.out.println(lit.nextIndex()+":"+lit.next());
		}
		System.out.println("------使用列表迭代器后往前-------");
		while(lit.hasPrevious()) {
			System.out.println(lit.previousIndex()+":"+lit.previous());
		}
		
		//4判断
		System.out.println(list.contains("苹果"));
		System.out.println(list.isEmpty());
		
		//5获取位置
		System.out.println(list.indexOf("华为"));
	}
}

LIst的实现类

1. ArrayList

数组结构实现，查询快、增删慢。线程不安全。

方法演示：ArrayList 、LinkedList等是实现类，重写了LIst接口的方法

public class TestArrayList {
	public static void main(String[] args) {
		//创建集合  size 0  容量 0，扩容原来的1.5倍
		ArrayList arrayList=new ArrayList<>();
		//1添加元素
		Student s1=new Student("刘德华", 20);
		Student s2=new Student("郭富城", 22);
		Student s3=new Student("梁朝伟", 18);
		arrayList.add(s1);
		arrayList.add(s2);
		arrayList.add(s3);
		System.out.println("元素个数:"+arrayList.size());
		System.out.println(arrayList.toString());
		//2删除元素
//		arrayList.remove(new Student("刘德华", 20));//equals(this==obj)
//		System.out.println("删除之后:"+arrayList.size());
		
		//3遍历元素【重点】
		//3.1使用迭代器
		System.out.println("-------3.1使用迭代器-----");
		Iterator it=arrayList.iterator();
		while(it.hasNext()) {
			Student s=(Student)it.next();
			System.out.println(s.toString());
		}
		//3.2列表迭代器
		ListIterator lit=arrayList.listIterator();
		System.out.println("-------3.2使用列表迭代器---------");
		while(lit.hasNext()) {
			Student s=(Student)lit.next();
			System.out.println(s.toString());
		}
		
		System.out.println("-------3.2使用列表迭代器逆序---------");
		while(lit.hasPrevious()) {
			Student s=(Student)lit.previous();
			System.out.println(s.toString());
		}
		
		//4判断
		System.out.println(arrayList.contains(new Student("梁朝伟", 18)));
		System.out.println(arrayList.isEmpty());
		
		//5查找
		System.out.println(arrayList.indexOf(new Student("梁朝伟", 18)));
	}
}

注意：List subList(int fromIndex, int toIndex)返回fromIndex和toIndex之间的集合元素，特点是左闭右开。

• LinkedList

链表结构实现，增删快，查询慢。
LinkedList存储结构是双向链表，删除、添加效率高。
//创建集合
LinkedList linkedList=new LinkedList();

• Vector

数组结构实现，查询快、增删慢。线程安全、运行效率比ArrayList较慢。

注：这几个实现类的方法使用都是差不多的，只是创建的集合对象的方式不同而已，因为属于不同的实现类。

泛型

概念：
Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。

优点

提高代码的重用性。
防止类型转换异常，提高代码的安全性。

set集合

特点：无序、无下标、元素不可重复。
方法：全部继承自Collection中的方法。
使用foreach循环遍历：
for(数据类型 局部变量 : 集合名){
//循环内部的局部变量，代表当次循环从集合中取出的对象
}

注：这个和List一样都属于Collection集合体系，所以他的方法和List都是一样的，最大的区别就是，set集合里面的元素是不可重复。

• set的实现类
  HashSet
  特点：

基于HashCode实现元素不重复。当存入元素的哈希码相同时，会调用==或equals进行确认，结果为true，拒绝后者存入。

public class TestHashSet2 {
	public static void main(String[] args) {
		//新建集合
		HashSet<String> hashSet=new HashSet<String>();
		//1添加元素
		hashSet.add("刘德华");
		hashSet.add("梁朝伟");
		hashSet.add("林志玲");
		hashSet.add("周润发");
		//hashSet.add("刘德华");
		System.out.println("元素个数:"+hashSet.size());
		System.out.println(hashSet.toString());
		//2删除数据
//		hashSet.remove("刘德华");
//		System.out.println("删除之后:"+hashSet.size());
		//3遍历操作
		//3.1增强for
		System.out.println("--------3.1增强for--------");
		for (String string : hashSet) {
			System.out.println(string);
		}
		//3.2使用迭代器
		System.out.println("-------3.2迭代器--------");
		Iterator<String> it=hashSet.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//4判断
		System.out.println(hashSet.contains("郭富城"));
		System.out.println(hashSet.isEmpty());
		
	}
}

注：

• 根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空执行第二步。
• 再执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表。
• [JDK1.8之后引入红黑树，提高效率。]

LinkedHashSet

链表实现的HashSet，按照链表进行存储，即可保留元素的插入顺序。

TreeSet

• 基于排列顺序实现元素不重复。
• 实现了SortedSet接口，对集合元素自动排序。
• 元素对象的类型必须实现Comparable接口，指定排序规则（自然排序）。
• 通过CompareTo方法确定是否为重复元素。

• Map集合
  特点：
  称为“映射”存储一对数据(Key-Value)，键不可重复，值可以重复。

map集合的使用：

public class TestMap {
	public static void main(String[] args) {
		//创建Map集合
		Map<String, String> map=new HashMap<>();
		//1添加元素
		map.put("cn", "中国");
		map.put("uk", "英国");
		map.put("usa", "美国");
		map.put("cn", "zhongguo");
		
		System.out.println("元素个数:"+map.size());
		System.out.println(map.toString());
		
		//2删除
//		map.remove("usa");
//		System.out.println("删除之后:"+map.size());
		//3遍历
		//3.1使用keySet();
		System.out.println("------keySet()--------");
		//Set<String> keyset=map.keySet();
		for (String key : map.keySet()) {
			System.out.println(key+"-----"+map.get(key));
		}
		//3.2使用entrySet()方法
		System.out.println("------entrySet()-----");
		//Set<Map.Entry<String, String>> entries=map.entrySet();
		for (Map.Entry<String, String> entry : map.entrySet()) {
			System.out.println(entry.getKey()+"---------"+entry.getValue());
		}
		//4判断
		System.out.println(map.containsKey("cn"));
		System.out.println(map.containsValue("泰国"));
		
	}
}

Map 的实现类

• HashMap【重点】

• JDK1.2版本，线程不安全，运行效率快。

• 允许用null 作为key或是value。
• 存储结构：哈希表。

public class TestHashMap {
	public static void main(String[] args) {
	
		//创建集合
		HashMap<Student, String> students=new HashMap<Student,String>();
		//刚创建hashmap之后没有添加元素 table=null   size=0 目的节省空间
		//1添加元素
		Student s1=new Student("孙悟空", 100);
		Student s2=new Student("猪八戒", 101);
		Student s3=new Student("沙和尚", 102);
		students.put(s1, "北京");
		students.put(s2, "上海");
		students.put(s3, "杭州");
		//students.put(s3, "南京");
		students.put(new Student("沙和尚", 102), "杭州");
		System.out.println("元素个数:"+students.size());
		System.out.println(students.toString());
		//2删除
//		students.remove(s1);
//		System.out.println("删除之后"+students.size());
		//3遍历
		System.out.println("--------keySet---------");
		//3.1使用keySet();
		for (Student key : students.keySet()) {
			System.out.println(key.toString()+"========="+students.get(key));
		}
		System.out.println("--------entrySet---------");
		//3.2使用entrySet();
		for (Map.Entry<Student, String> entry : students.entrySet()) {
			System.out.println(entry.getKey()+"---------"+entry.getValue());
		}
		//4判断
		System.out.println(students.containsKey(new Student("孙悟空", 100)));
		System.out.println(students.containsValue("杭州"));
		
	}
}