2017年4月7号 空气质量：中度污染
内容：枚举，包装类，String类，String,StringBuffer,StringBuilder三者区别
一、枚举
老师代码：
（1）学生实体类
package cn.bdqn.enumDemo;
//学生的实体类
public class Student {
private String name; // 姓名
private Gender sex; // 性别
public Gender getSex() {
return sex;
}
public void setSex(Gender sex) {
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Student(String name, Gender sex) {
super();
this.name = name;
this.sex = sex;
}
public Student() {
super();
}
@Override
public String toString() {
return "Student [name=" + name + ", sex=" + sex + "]";
}
// 测试方法
public static void main(String[] args) {
// 创建student对象
Student student = new Student();
/**
* 给学生对象的性别属性赋值
student.setSex("人妖"); 不健康的输入
怎么解决？
01.在对应的set方法中加入逻辑判断
02.使用enum
001.创建一个枚举类
002.创建枚举值
003.把需要限定的属性的类型改成枚举类即可！
student.setSex(Gender.男); ===>枚举类中有 男，女
System.out.println("学生的性别是：" + student.getSex());
*/
student.setSex(Gender.Man);
System.out.println("学生的性别是：" + student.getSex());
// Gender.values()获取所有的枚举值 是个数组
for (Gender g : Gender.values()) {
System.out.println(g.getSex());
}
}
}
（2）枚举类
package cn.bdqn.enumDemo;
/**
* 枚举类
* 01.限定用户的输入
* 02.所有的枚举值都是static final修饰的！（静态常量）
* 03.构造必须是私有的！防止外部访问！
*/
public enum Gender {
Man(1, "男"), Woman(0, "女");// 枚举值
private int index;
private String sex;
private Gender(int index, String sex) {
this.index = index;
this.sex = sex;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
二、包装类
1、老师代码：
package cn.bdqn.pack;
import org.junit.Test;
public class BasicTest {
/**
* 封装类/包装类： 把 基本数据类型转换成了一个对象！
* 所有的包装类都是final 修饰的！ 不能有子类！
*
* 每个基本数据类型在java.lang包下面，都有相应的包装类
* 除了 int 和 char的包装类！其他的6个基本数据类型的包装类都是首字母大写！
* 基本数据类型 包装类
* byte Byte
* short Short
* int Integer
* long Long
* float Float
* double Double
* char Character
* boolean Boolean
*
* 包装类的作用
* 01.提供了一系列的实用方法
* 02.集合中不允许存放基本数据类型！必须使用对应的包装类！
*
*
* 数值类型的6个包装类都继承了Number类！
* Character，Boolean，Number都类实现了Serializable接口！
*
* 问题？
* 有一个方法，参数的是Serializable类型！
* 那么，我们可以传递什么实际参数？？
* 只要是实现Serializable接口的类 都可以作为参数！
*
*
* public static void getSum(Serializable s) {
System.out.println(s);
* }
* public static void main(String[] args) {
getSum(1.0);
getSum(1);
getSum('a');
getSum(true);
getSum("a"); // 为什么String也可以
}
*
*/
// 所有的封装类 都有将对应的基本数据类型作为参数 来构造实例
@Test
public void test01() {
Byte a = new Byte((byte) 1);
Short b = new Short((short) 1);
Integer c = new Integer(1);
Long d = new Long(1);
Double f = new Double(1.0);
Boolean h = new Boolean(true);
Float e = new Float(1.0); // float 有三个构造重载 多了一个double类型的值作为参数 来构造实例
System.out.println("以上7种都有String作为参数来构造实例");
// 没有String作为参数来 构造实例 String底层默认就是char[]
Character g = new Character('1');
}
/**
* Boolean类型构造方法的参数是String类型的时候，
* 如果字符串的内容是true(不区分大小写)，则结果为true！
* 否则！都是false！
*/
@Test
public void test02() {
Boolean b = new Boolean("TRUE");
b = new Boolean("true");
System.out.println(b);
}
/**
* 当包装类构造方法参数是String类型的时候，
* 01.参数不能为null 空值！（空串指的是" "）
* 02.字符串必须是全数值类型的！
* 否则 都会出现 NumberFormatException!
*/
@Test
public void test03() {
Integer i = new Integer(null);
i = new Integer("a12");
}
/**
* 包装类.valueOf(对应的基本数据类型)：
* 返回一个表示指定的 基本数据类型（比如int） 值的 包装类（比如Integer）实例
*
* 包装类.valueOf(String类型的值) 除了Character之外
* 01底层默认执行了 parseXXX（）
* 02.如果String类型的值不是全数值类型，则也抛出NumberFormatException
*/
@Test
public void test04() {
Integer i = Integer.valueOf(1);
i = Integer.valueOf("123a");
System.out.println(i);
}
/**
* XXXValue():包装类转换成基本数据类型！
*/
@Test
public void test05() {
Integer i = new Integer(1);
int a = i.intValue();
System.out.println(i + 1);
}
/**
* toString():以字符串的形式返回包装类对应的基本数据类型
*/
@Test
public void test06() {
Integer i = new Integer(1);
System.out.println(i.toString() + 2);// i.toString()===>"1"
}
/**
* parseXXX():把字符串转换成对应的基本数据类型
* 除了 Character没有！
*/
@Test
public void test07() {
Integer i = new Integer(1);
int a = i.parseInt("5");
System.out.println(a + 1);
}
/**
* 装箱：把基本数据类型转换成包装类的对象
* 拆箱：包装类对象转化成基本数据类型的值
*/
@Test
public void test09() {
Integer i = 5; // 5是int类型 自动装箱
int a = i; // i是包装类 自动拆箱
System.out.println(a);
}
/**
* 底层默认执行了valueOf（int i）
* 如果i 在 -128 -- +127之间，不会new对象
* 否则new 新对象并返回！
*/
@Test
public void test10() {
Integer a = 127;
Integer b = 127;
System.out.println(a == b); // 需要查看具体 的值
Integer a1 = 128;
Integer b1 = 128;
System.out.println(a1 == b1); // 需要查看具体 的值
}
}
2、图示及课堂小练习题
三、String类
老师代码：
package cn.bdqn.string;
import org.junit.Test;
public class StringTest {
/**
* 01.String是不可改变的对象
* 02.经常被改变内容的字符串尽量不要使用String（每次都内存中创建一个新对象）
* 03.StringBuffer是可变的字符串
* 04.经常改变的字符串 应该使用StringBuffer！效率高！
* 05.1.5之后有StringBuilder!效率是最高的！但是线程不安全！
* 同样的数据操作量耗时对比：String > StringBuffer > StringBuilder
*/
// length() 返回字符串的长度
@Test
public void test01() {
String a = "abc";
System.out.println("字符串的长度：" + a.length());
}
/**
* String只是重写了Object类中的equals（）；
* 在Object类中的equals默认也是比较的内存地址！
* （基本数据类型比较的是值 和 引用数据类型比较的是内存地址）
*
* a.equals(b)比较内容 区分大小写
*
* 01.先比较两者的内存地址，如果相同直接返回true
* 02.看b是不是String类型
* 03.再比较两者的长度
* 04.因为Stirng底层是一个char[]类型的数组，循环比较每一个字符的值
* 05.相等返回true
*
* equalsIgnoreCase:不区分大小写 内容比较
*/
@Test
public void test02() {
String a = "abc";
String b = "ABC";
String c = "abc";
System.out.println("a.equals(b):" + a.equals(b));
System.out.println("a.equalsIgnoreCase(b):" + a.equalsIgnoreCase(b));
System.out.println("a.equals(c):" + a.equals(c));
}
/**
* toUpperCase()
* toLowerCase()
* 转换成大小写
*/
@Test
public void test03() {
String a = "abc";
System.out.println("转换成大写:" + a.toUpperCase());
System.out.println("转换成小写:" + "HAHA".toLowerCase());
}
/**
* toCharArray()
* 把字符串转换成数组？？字符数组？
*/
@Test
public void test04() {
String a = "大家辛苦了！";
char[] array = a.toCharArray();
/**
* array:需要遍历的集合名称
* c:变量名称
* char:集合中元素的类型
*/
for (char c : array) {
System.out.println(c);
}
}
/**
* 以指定的字符作为分割点，把字符串拆分成 ！字符串数组！
* split(regex):
* regex==>正则表达式！！！！ 有种你别看！！
* 如果说 regex是正则表达式中的关键字 需要用 转义符 转义才能使用！
*/
@Test
public void test05() {
String a = "大家[辛苦了！";
String[] split = a.split("辛");
String[] split1 = a.split("\[");// 需要用 转义符 转义才能使用
for (String string : split1) {
System.out.println(string);
}
}
/**
* 邮箱 必须有 @ .
* 5018@qq.com
* 查询字符 在字符串中的位置
* indexOf： 第一次出现的位置
* lastIndexOf：最后一次出现的位置
*/
@Test
public void test06() {
String a = "大家辛苦了！真的辛苦！";
int index = a.indexOf("辛"); // 下标从0 开始
System.out.println(""辛"出现的位置:" + index);
index = a.lastIndexOf("辛");
System.out.println(""辛"最后出现的位置:" + index);
}
/**
* 截取字符串
* substring(int beginIndex)：从beginIndex开始截取，包含自身位置！并且返回String!
* substring(int beginIndex,int endIndex)：
* 从beginIndex开始截取， 到endIndex结束！并且返回String!
* 包含beginIndex位置！不包含endIndex位置！
*/
@Test
public void test07() {
String a = "大家辛苦了！真的辛苦！";
/**
* a = a.substring(1); System.out.println(a);
*/
a = a.substring(1, 3);
System.out.println(a);
}
/**
* trim
* 去掉字符串两边的空格
*/
@Test
public void test08() {
String a = " 大家辛苦了 ";
System.out.println(a.length()); // 空格算入了长度
a = a.trim();
System.out.println(a.length());
}
/**
* replace(old,new)
* 替换指定的字符或者是字符串
*/
@Test
public void test09() {
String a = "大家辛苦了";
a = a.replace('家', 'a');// 大a辛苦了
a = a.replace("大a", "小家");
System.out.println(a);
}
/**
* 返回指定位置的字符！
* charAt
*/
@Test
public void test10() {
String a = "大家辛苦了";
char result = a.charAt(2);
System.out.println(result);
}
/**
* getBytes()
* 把字符串 存在 字节数组中
* 字符的编码格式的由来！ 有种你别看！
*/
@Test
public void test11() {
String a = "大家辛苦了";
byte[] bytes = a.getBytes();
for (byte b : bytes) {
System.out.println((char) b);
}
}
/**
* 字符串的拼接
* + 可以拼接任意类型
* concat():只能传递String类型的值
*/
@Test
public void test12() {
String a = "大家辛苦了";
a = a.concat("!真的苦！");
System.out.println(a);
}
/**
* contains():查询字符串中是否包含某个字符串！
*/
@Test
public void test13() {
String a = "大家辛苦了";
System.out.println(a.contains("大家辛"));
}
}
四、String,StringBuffer,StringBuilder三者区别
老师代码：
package cn.bdqn.string;
import org.junit.Test;
public class StringBufferAndStringBuilder {
/*
* String, StringBuffer ,StringBuilder三者的区别
* 01.执行速度 StringBuilder >StringBuffer > String
* 02.StringBuilder:多线程不安全，适合单线程;StringBuffer：线程安全;String:数据量小的时候使用
* 03.String 是不可变的！每当我们操作字符串的时候，都会创建一个新的对象！
* StringBuilder，StringBuffer当我们操作字符串的时候，实际上是在操作一个对象！
*/
@Test
public void test11() {
// 01.定义变量
String name = "xiaohei";
// 02.定义操作字符串的次数
int count = 200000;
// 03.设置开始时间
long beginTime = System.currentTimeMillis();
for (int i = 0; i < count / 100; i++) {
name += "haha";
}
// 03.设置结束时间
long endTime = System.currentTimeMillis();
System.out.println("String的执行时间：" + (endTime - beginTime));
System.out.println("****************************");
name = "xiaohei";
// 04.使用StringBuffer
StringBuffer buffer = new StringBuffer(name);
beginTime = System.currentTimeMillis();
for (int i = 0; i < count; i++) {
buffer = buffer.append("haha");
}
endTime = System.currentTimeMillis();
System.out.println("StringBuffer的执行时间：" + (endTime - beginTime));
System.out.println("****************************");
name = "xiaohei";
// 05.使用StringBuilder
StringBuilder builder = new StringBuilder(name);
beginTime = System.currentTimeMillis();
for (int i = 0; i < count; i++) {
builder = builder.append("haha");
}
endTime = System.currentTimeMillis();
System.out.println("StringBuilder的执行时间：" + (endTime - beginTime));
}
}
五、作业
1、视频看完IO流
周末准备挑灯夜战
2、总结实用类和IO流的笔记，下次上课交
周末准备挑灯夜战
3、做题
六、考试
2017.04.07
15: 15开始，16:05结束；答题时间：50 分钟；检查时间：0 分钟；
成绩：88 分
从进入面向对象以来，每次考试中间都要出去透口气(有时还不止一次)，感觉答完50题后特别疲惫，跟平时做题少有直接关系。
现在愈发体会到硕哥说的“不要大起大伏，要持续平稳的坚持学习”。还好目前进度还算勉强跟得上，要坚持不放松！
成功的路上并不拥挤，因为坚持下来的总是少数。期待和我的战友们都坚持到最后，终生学习。
待到大家都事业有小成时再把酒言欢。现在就是苦逼的时候，加油！
七、老师辛苦了！
