单元测试
说明
1）Junit一个java语言的单元测试框架，属于白盒测试，简单理解为可以取代java的main方法
2）Junit属于第三方工具，需要导入jar包后才能使用
代码实现
package cn.liu.a_junit;
import org.junit.After;
import org.junit.Before;
import static org.junit.Assert.*;
public class ProductServerTest {
ProductServer p2 = new ProductServer();
//添加@Before注解在执行测试方法前执行。
@Before
public void init() {
System.out.println("111,连接数据库资源。。。。");
}
//@After在执行测试方法后执行。。
@After
public void destory() {
System.out.println("222,释放数据库资源。。。。");
}
@org.junit.Test
public void add() {
p2.add();
}
@org.junit.Test
public void del() {
p2.del();
}
@org.junit.Test
public void edit() {
p2.edit();
}
@org.junit.Test
public void query() {
p2.query();
}
}
内部类
说明
1）类里边还有一个类, 外边那个类叫做外部类, 里边那个类叫做内部类
2)
1- 成员内部类
public class A { //外部类
public class B{ //成员内部类
}
}
2- 局部内部类
public class A { //外部类
//外部类的成员方法
public void show() {
//局部内部类
class B {
}
3）匿名内部类：指的就是没有名字的局部内部类.
内部类的代码样例
public class WordCount {
public static void main(String[] args) {
//1 读
//2 mapper分
WordCountMapper c1 = new WordCountMapper();
c1.map();
//3 分区
//4 排序
//5 规约
//6 分组
//7 reduce 合
WordCountReduce r1 = new WordCountReduce();
r1.reduce();
}
//内部类
public static class WordCountMapper {
//创建分的方法
public void map() {
System.out.println("分的业务逻辑。。。。");
}
}
//内部类
public static class WordCountReduce {
//创建合的方法
public void reduce() {
System.out.println("合的业务逻辑。。。。");
}
}
}
匿名内部类的代码样例
注：• 当对对象方法(即: 成员方法)仅调用一次的时候.
• 匿名内部类可以作为方法的实参进行传递.
public class Demo01 {
public static void main(String[] args) {
//定义匿名内部类
animalMethod(new Animal() {
@Override
public void eat() {
System.out.println("1 动物正在吃空气 ... ...");
}
@Override
public void sleep() {
System.out.println("2 动物正在太空睡觉 ... ...");
}
});
}
//定义一个动物方法
public static void animalMethod(Animal animal) {
animal.eat();
animal.sleep();
}
}
//定义一个抽象的动物类
abstract class Animal {
//定义抽象的方法eat,sleep
public abstract void eat();
public abstract void sleep();
}
集合
说明
1）集合是用来存储多个同类型数据的容器, 它的长度是可以变化的.
2）集合的顶层都是接口，其中collection接口是单列集合的顶层接口，map接口是双列集合的顶层接口
3）collection接口有两大子体系：
1- list体系：有序，可重复
2- Set体系：无序，唯一
4）集合的成员方法
1-
集合的快速入门代码样例
import java.util.ArrayList;
import java.util.Collection;
public class Collect {
public static void main(String[] args) {
/*
创建Collection集合对象, 用来存储字符串.
调用Collection接口的add()方法, 往上述集合中添加3个字符串, 内容如下:
"hello", "world", "java"
*/
//集合的优点：类型不固定，长度无限制
Collection a1 = new ArrayList();
a1.add(123);
a1.add("dfs");
a1.add(true);
System.out.println(a1);
//通过泛型定义集合的元素类型
Collection<String> a2 = new ArrayList<>();
a2.add("aaa");
a2.add("3df");
System.out.println(a2);
}
}
集合常用的成员方法
1. public boolean add(E e) 添加元素.
2. public boolean remove(Object obj) 从集合中移除指定的元素.
3. public void clear() 清空集合对象
4. public boolean contains(Object obj) 判断集合中是否包含指定的元素
5. public boolean isEmpty() 判断集合是否为空
6. public int size() 获取集合的长度, 即集合中元素的个数
代码样例
package cn.liu.a;
import java.util.ArrayList;
import java.util.Collection;
public class Collect_01 {
public static void main(String[] args) {
Collection<String> cc1 = new ArrayList<>();
cc1.add("hello");
cc1.add("world");
cc1.add("java");
System.out.println(cc1);
System.out.println("=========");
//删除集合中的字符(默认只删除第一个)
cc1.remove("java");
System.out.println(cc1);
System.out.println("===============");
//清空集合中的元素
cc1.clear();
System.out.println(cc1);
System.out.println("================");
//查看集合是否为空
System.out.println(cc1.isEmpty());
//查看集合中是否存在hello
cc1.add("hello");
cc1.add("world");
System.out.println(cc1.contains("hello"));
//查看集合中元素的个数
System.out.println(cc1.size());
}
}
集合的遍历
package cn.liu.a;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Collect_02 {
public static void main(String[] args) {
//创建集合
Collection<String> c3 = new ArrayList<>();
c3.add("hello");
c3.add("world");
c3.add("java");
//遍历集合(快捷键 itit)
Iterator<String> it1 = c3.iterator();
while (it1.hasNext()) {
String element = it1.next();
System.out.println(element);
}
//遍历方式二 c3.iter
for (String elem : c3) {
System.out.println(elem);
}
}
}
向集合中保存对象类型
class Demo001 {
public static void main(String[] args) {
//向集合保存学生对象类型
Collection<Student01> c5 = new ArrayList<>();
c5.add(new Student01("张三",15));
c5.add(new Student01("李四",18));
c5.add(new Student01("王五",9));
//for循环遍历
for (Student01 i : c5) {
System.out.println(i);
}
//迭代器遍历
Iterator<Student01> it = c5.iterator();
while (it.hasNext()) {
Student01 it01 = it.next();
System.out.println(it01);
}
}
}
list集合的子类
说明
1）List集合是一个接口, 它的常用子类有两个, 分别是ArrayList,LinkedList.
1- ArrayList集合的特点: 底层数据结构是数组, 查询和修改快, 增删慢.
2- LinkedList集合的特点: 底层数据结构是链表, 查询和修改慢, 增删快.
注: 它们的相同点是, 都是有序的, 而且可以存储重复元素
代码样例
public class Demo003 {
public static void main(String[] args) {
ArrayList<Student01> l1 = new ArrayList<>();
l1.add(new Student01("zhangsan", 48));
l1.add(new Student01("lisi", 48));
l1.add(new Student01("wangwu", 48));
//通过下标后去元素
System.out.println(l1.get(0));
System.out.println(l1.get(1));
//通过下标修改元素
l1.set(2, new Student01("王五", 19));
System.out.println(l1.get(2));
//通过下标删除元素
l1.remove(0);
System.out.println(l1.get(0));
}
}
list列表迭代器
- 说明
普通的迭代器只能向下寻找，不能向前寻找。
通过列表迭代器可以解决并发异常。
//方式三：listIterator遍历数据(向下遍历)
ListIterator<Student01> list02 = list01.listIterator();
while (list02.hasNext()) {
Student01 ss = list02.next();
System.out.println(ss);
}
System.out.println("=========================");
//方式三：listIterator遍历数据(向上遍历)
while (list02.hasPrevious()) {
Student01 p1 = list02.previous();
System.out.println(p1);
}
常见的数据结构
栈和队列
1）栈的特点是：调用方法时时后进先出的
2) 队列的特点：先进先出
数组和链表
1）数组查询时比较方便，但是在增删是效率比较慢，因为数组不能直接修改，需要新建一个数组来改删
2）链表的查询比较慢，但是增删的效率比较快
Set集合
- 说明
1）Set集合是Collection集合的子体系, 它的元素特点是无序, 唯一
2） Set集合是一个接口, 所以不能通过new的方式直接创建它的对象.
3） Set集合中没有带索引的方法, 所以不能通过普通for循环遍历.
4） Set集合的常用子类主要有两个, 分别是HashSet集合和TreeSet集合
注：在对对象去重时，需要重写Hashcode
- 对比set和list的区别代码样例
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class Demo04 {
public static void main(String[] args) {
//调用method01
// method01();
Set<String> set01 = new HashSet<>();
set01.add("hello");
set01.add("hello");
set01.add("hello");
set01.add("hello");
set01.add("hello");
set01.add("hello");
System.out.println(set01);
}
private static void method01() {
//创建一个列表
List<String> list01 = new ArrayList<>();
//添加元素
list01.add("hello");
list01.add("hello");
list01.add("hello");
list01.add("hello");
System.out.println(list01);
}
}
set集合的遍历
- 说明
1）set的遍历可以通过两种方式实现
1- 增强for循环：iter
2- 迭代器： iterator()
map类型
map的核心API
map的入门代码
import java.util.HashMap;
import java.util.Map;
public class Demo05 {
public static void main(String[] args) {
method01();
//数据类型换成类名
Map<Integer, Student01> m02 = new HashMap<>();
m02.put(01, new Student01("YANGUO",20));
m02.put(02, new Student01("小龙女", 30));
//remove删除k
m02.remove(key:01)
//清空map
m02.clear();
//map中是否包含某个k
boolean flag = m02.containsKey(01)
//map中是否包含某个值
boolean flag2 = m02.containsValue(new Student01("YANGUO",20))
System.out.println(m02);
}
public static void method01() {
//定义一个map类型
Map<Integer, String> m01 = new HashMap();
//添加数值
m01.put(01, "杨过");
m01.put(02, "小龙女");
m01.put(03, "老顽童");
System.out.println(m01);
}
}
map集合的获取功能
功能实现代码样例
Map<Integer, Student01> m03 = new HashMap<>();
m03.put(01, new Student01("杨过",20));
m03.put(02, new Student01("小龙女", 30));
m03.put(03, new Student01("周芷若", 80));
//根据k键获取值
System.out.println(m03.get(03));
//获取所有键的集合
Set<Integer> m04 = m03.keySet();
System.out.println(m04);
//获取所有值的集合
Collection<Student01> v01 = m03.values();
System.out.println(v01);
map的遍历
//方式一：遍历map
Set<Integer> k01 = m03.keySet();
for (Integer element : k01) {
String v01 = k01.get(element);
}
System.out.println(v01);
//方式二：遍历map
Set<Map.Entry<Integer, Student01>> en01 = m03.entrySet();
for (Map.Entry<Integer, Student01> en02 : en01) {
Integer k01 = en02.getKey();
Student01 v01 = en02.getValue();
System.out.println(k01+ "=========" + v01);
collections集合工具类
常用方法
- 代码样例
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Demo01_collections {
public static void main(String[] args) {
//定义一个集合
List<Integer> a1 = new ArrayList<>();
a1.add(110);
a1.add(341);
a1.add(14);
a1.add(145);
System.out.println("排序前" + a1);
//进行排序sort
Collections.sort(a1);
System.out.println("排序后" + a1);
//将顺序反转reverse
Collections.reverse(a1);
System.out.println("返转后" + a1);
//打乱顺序shuffle
Collections.shuffle(a1);
System.out.println("洗牌后" + a1);
}
}
可变参数
代码样例
public class Demo02_kebian {
public static void main(String[] args) {
int a = 12;
int b = 3;
int c = 2;
int d = 45;
int result01 = getsum(a, b);
int result02 = getsum(a, b, c);
int result03 = getsum(a, b, c, d);
System.out.println(result01);
System.out.println(result02);
System.out.println(result03);
}
public static int getsum(int... params) {
int sum = 0;
for (int p1 : params) {
sum += p1;
}
return sum;
}
}
反射
获取类的字节码对象代码样例
package cn.liu.b;
import cn.liu.a.Demo04;
public class Demo04_reflect {
public static void main(String[] args) throws Exception {
//diyong();
//获取类的字节码对象：方式一
Class c1 = Demo03.class;
System.out.println(c1);
//获取类的字节码对象：方式二
Demo03 d1 = new Demo03();
Class c2 = d1.getClass();
System.out.println(c2);
//获取类的字节码对象：方式三(常用)
Class c3 = Class.forName("cn.liu.b.Demo03");
System.out.println(c3);
}
public static void diyong() {
//私有构造在类外不能调用
// Demo03 d1 = new Demo03("zhansan");
//私有方法在类外不能调用
Demo03 d2 = new Demo03();
d2.show1();
// d2.show4()
//私有的属性在类外面也不能调用
Demo03 d3 = new Demo03();
// d3.name();
}
}
lamdba表达式
说明
1）lamdba表达式是一个匿名函数
2）并不是所有的接口都可以用lamdba表达式实现，要求接口中定义的必须要实现一个抽象的方法
lamdba语法格式
//方式一
//实现无参数无返回值的接口
LambdaNoneReturnNoneParmeter lam01 = new LambdaNoneReturnNoneParmeter() {
@Override
public void test() {
System.out.println("实现无参数无返回值的接口。。。");
}
};
lam01.test();
//方式二
LambdaNoneReturnNoneParmeter lam02 = () -> {
System.out.println("实现无参数无返回值的接口。。。");
};
lam02.test();
//方式三
LambdaNoneReturnNoneParmeter lam03 = () -> System.out.println("实现无参数无返回值的接口。。。");
lam03.test();
}
- lamdba精简写法
// 精简前
LambdaSingleReturnMutipleParmeter lambda1 = (a, b) -> a + b;
LambdaSingleReturnMutipleParmeter lambda2 = (a, b) -> a * b;
// 精简后
LambdaSingleReturnMutipleParmeter lambda3 = (a, b) -> MyStaticClass.add(a, b);
LambdaSingleReturnMutipleParmeter lambda4 = MyStaticClass::multiplication;
}
Flie类
- File的构造方法
- 常用功能
- Flie的判断和获取工能
IO流
说明
1）IO流用来处理设备间的数据传输问题的
I：input O：output
2）字节流：以字节为单位来操作数据.
字符流: 以字符为单位来操作数据
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
