2017年4月3号课堂笔记

Posted 2020-09-08 不抽烟的香吉士

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了2017年4月3号课堂笔记相关的知识，希望对你有一定的参考价值。

2017年4月3号重度雾霾

内容：log4j,集合框架（ArrayList,LinkedList）

一、log4j

老师代码：

1）log4j.properties:

log4j.appender.console=org.apache.log4j.ConsoleAppender

log4j.appender.console.target=System.err

log4j.appender.console.layout=org.apache.log4j.PatternLayout

log4j.appender.console.layout.conversionPattern=[%-5p] [%d{hh:mm:ss}] %c %l %m%n

log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=e:/bdqn.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.conversionPattern=[%-5p] [%d{hh:mm:ss}] %c %l %m%n

//在console台上和文件里都输出：

log4j.rootLogger=trace,console,file

//console台上输出TestLog4j的所有

//console台上输出UtilTest的warn以上的3组信息

2)测试类TestLog4j:

package cn.log4j.test;

import org.apache.log4j.Logger;

public class TestLog4j {
/**
* log4j错误的级别由大到小！
* fatal
* error
* warn
* info
* debug
* trace
*
* off:不显示任何信息！
* all:显示有的信息！
*
* 01.将信息显示在console台上
* log4j.appender.console=org.apache.log4j.ConsoleAppender
* ConsoleAppender console=new ConsoleAppender();
*
* 02.显示的格式
* log4j.appender.console.layout=org.apache.log4j.PatternLayout
* PatternLayout layout=new PatternLayout();
*
* 03.自定义显示格式
* conversionPattern=自定义的匹配格式
*
* log4j.rootLogger=级别，变量1,变量2...
*
* 显示在电脑中的某个文件夹如果不指定路径默认是在项目的根目录下
* log4j.appender.file=org.apache.log4j.FileAppender
* log4j.appender.file.File=e:/bdqn.log
*/
public static void main(String[] args) {

Logger logger = Logger.getLogger(TestLog4j.class);
logger.fatal("fatal msg");
logger.error("error msg");
logger.warn("warn msg");
logger.info("info msg");
logger.debug("debug msg");
logger.trace("trace msg");

}

二、为什么需要集合？

三、ArrayList

老师代码：

公用的两个实体类：

1）动物类:

package cn.bdqn.bean;

/**
* 动物类
*/
public abstract class Animal {

private String name; // 姓名
private int health; // 健康值
private int love; // 亲密度

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getHealth() {
return health;
}

public void setHealth(int health) {
this.health = health;
}

public int getLove() {
return love;
}

public void setLove(int love) {
this.love = love;
}

public Animal(String name, int health, int love) {
super();
this.name = name;
this.health = health;
this.love = love;
}

public Animal() {
super();
}

// 自我介绍的方法
public abstract void showInfo();

}

2）狗狗类:

package cn.bdqn.bean;

/*
* 狗狗类
*/
public class Dog extends Animal {
// 品种
private String strain;

// 重写父类的方法
@Override
public void showInfo() {
System.out.println("姓名：" + this.getName());
System.out.println("健康值：" + this.getHealth());
System.out.println("亲密度：" + this.getLove());
System.out.println("品种：" + this.strain);
}

public String getStrain() {
return strain;
}

public void setStrain(String strain) {
this.strain = strain;
}

public Dog(String name, int health, int love, String strain) {
super(name, health, love);
this.strain = strain;
}

public Dog(String name, int health, int love) {
super(name, health, love);
}

public Dog() {

}

3） ArrayListTest:

package cn.bdqn.test;

import java.util.ArrayList;
import java.util.List;

import cn.bdqn.bean.Dog;

public class ArrayListTest {

/**
* ArrayList是List接口的实现类！
* 底层默认使用的是Object类型的数组！
* 特点：
* 存储的是一组不唯一，有序的数据！
* 遍历和随机访问元素的性能高！因为有下标！
*/
public static void main(String[] args) {
// 创建3个狗狗对象
Dog dog1 = new Dog("小狗1", 50, 100, "小狼狗1");
Dog dog2 = new Dog("小狗2", 50, 100, "小狼狗2");
Dog dog3 = new Dog("小狗3", 50, 100, "小狼狗3");

/** 之前的数组
* Dog[] dogs = new Dog[30];
dogs[0]=dog1;
dogs[1]=dog2;
dogs[2]=dog3;*/

// 使用ArrayList集合来保存3个小狗狗的信息
List dogs = new ArrayList();
// 向集合中增加数据
dogs.add(dog1);
dogs.add(dog2);
dogs.add(0, dog3);
// 输出集合的大小
System.out.println("dogs集合中一共有多少个数据？" + dogs.size());
// 遍历集合中所有的数据 shift +alt +m 提取成方法
forArrays(dogs);
/**
* 从集合中删除指定的对象
* dogs.remove(0); 从指定的位置删除
* dogs.remove(Object obj); 删除指定的对象
*/
dogs.remove(0); // 把下标为0 的对象删除
System.out.println("0000000000000000000删除之后的数据0000000000000000000");
forArrays(dogs);
// 查询集合中是否包含某个对象
System.out.println("集合中是否包含dog3?" + dogs.contains(dog3));
}

// 遍历集合中所有的数据
public static void forArrays(List dogs) {
for (int i = 0; i < dogs.size(); i++) {
/**
* 因为我们没有指定集合的类型
* 在底层给我们生成的数组是Object类型
* 而我们往集合中增加的数据是Dog类型
* 需不需要转换？我们需要向下转型
* dogs.get(i) 获取集合中指定下标位置的对象
*/
Dog dog = (Dog) dogs.get(i);
// 调用dog类中的自我介绍的方法
dog.showInfo();
System.out.println("**************************");
}
}

}

四、LinkedList

老师代码：

LinkedListTest:

package cn.bdqn.test;

import java.util.LinkedList;
import java.util.List;

import cn.bdqn.bean.Dog;

public class LinkedListTest {

/**
* LinkedList是List接口的实现类！
* 底层默认使用的是链表式的存储结构！
*
* 特点：
* 存储的是一组不唯一，有序的数据！
* 在新增和删除数据的时候，效率高！
*/
public static void main(String[] args) {
// 创建3个狗狗对象
Dog dog1 = new Dog("小狗1", 50, 100, "小狼狗1");
Dog dog2 = new Dog("小狗2", 50, 100, "小狼狗2");
Dog dog3 = new Dog("小狗3", 50, 100, "小狼狗3");

// 将三个对象放入集合中
LinkedList dogs = new LinkedList();
dogs.add(dog1);
dogs.add(dog2);
dogs.addFirst(dog3); // 在集合的第一个位置插入数据
forArrays(dogs);
/**
* 删除第一个对象
* dogs.remove();默认删除第一个对象
*/
dogs.removeFirst();
System.out
.println("...........................删除之后...........................");
forArrays(dogs);
// 集合中是否包含某个对象
System.out.println("集合中是否包含dog3?" + dogs.contains(dog3));

}

// 遍历集合中所有的数据
public static void forArrays(List dogs) {
for (int i = 0; i < dogs.size(); i++) {
Dog dog = (Dog) dogs.get(i);
// 调用dog类中的自我介绍的方法
dog.showInfo();
System.out.println("**************************");
}
}

}

五、String和字符串池

1）老师代码：

StringTest:

package cn.bdqn.test;

import java.util.HashSet;
import java.util.Set;

import org.junit.Test;

public class StringTest {
/**
*
* 基本数据类型 ==：比较是的值
* 引用数据类型 ==：比较是的内存地址
*/
@Test
public void test01() {
String name1 = "abc";
/**
01.在常量池中寻找有没有"abc" ；
02.没有就创建一个"abc" 开辟空间在常量池中
03.栈中name1 指向常量池中 "abc"
*/
String name2 = "abc";
/**
01.在常量池寻找有没有"abc" ；
02.发现有"abc"
03.栈中name2 指向常量池中 "abc"
*/
System.out.println(name1 == name2); // true
}

@Test
public void test02() {
String name1 = new String("abc");
/**
* 01.先在栈中开辟空间存储name1
* 02.在常量池寻找有没有"abc"
* 03.发现没有就在常量池中创建一个"abc"
* 04.去堆中再创建一个 "abc"
* 05.name1执行了堆中"abc"
*/
String name2 = new String("abc");
/**
* 01.先在栈中开辟空间存储name2
* 02.在常量池寻找有没有"abc"
* 03.发现有就不在常量池中创建对象
* 04.去堆中创建一个 "abc"
* 05.name2执行了堆中"abc"
*/
System.out.println(name1.equals(name2)); // true
System.out.println(name1 == name2); // false
}

@Test
public void test03() {
String name1 = "abcd";
String name2 = "abc";
String name3 = name2 + "d";
/**
name2是一个变量！系统在编译的时候不会把"abc"立即给name2
*/
System.out.println(name1.equals(name3)); // true
System.out.println(name1 == name3);// false
}

@Test
public void test04() {
String name1 = "abcd";
final String name2 = "abc"; // 常量
String name3 = name2 + "d";
/**
name2是一个常量！系统在编译的时候立即把"abc"给name2
*/
System.out.println(name1 == name3);// true
}

@Test
public void test05() {
String name1 = "abcd";
String name2 = "abc" + "d"; // 常量
System.out.println(name1 == name2);// true
}

@Test
public void test06() {
String name1 = "abcd";
String name2 = new String("abcd");
System.out.println(name1 == name2); // 内存地址不一样
System.out.println(name1.hashCode() == name2.hashCode());// hash值一致
Set set = new HashSet();
set.add(name1);
set.add(name2);
System.out.println(set.size()); // 先判断hash值，之后再看内存地址和内容
/***
* 底层代码
* if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
*/