类的两个要素：
属性三要素：（修饰符）；类型，名字，值
方法五要素：修饰符，返回值，方法名，形参，方法体
构造方法：是一个特殊的方法
抽象方法：是一个特殊的方法
抽象类：是一个特殊的抽象类
接口：是一个特殊的抽象类
接口中的方法全部是抽象的
接口中的属性全部是public static final 修饰
jdk1.8新特性
在接口中的方法可以有方法体
1.特殊接口
为什么接口中的方法要有方法体：
接口就是为了定标准，这个标准要求所有的实现类，实现抽象方法
其实有些方法，所有的实现类代码都是一样的；干脆就把这些代码挪到接口中
特殊接口必须被default修饰
示例：
IAnimal类
import java.util.function.Supplier;
/**
* 接口:
* 为什么接口中的方法要有方法体:
* 接口就是为了定标准,这个标准要求所有的实现类,实现抽象方法;
* 其实有些方法,所有的实现类代码都是一样的;干脆就把这些代码挪到接口中;
*/
public interface IAnimal{
// 属性
int HEAD_NUM = 1 ;
/* 下面的写法等同于上面的
* 被static修饰的,名字都是大写,
* 但是驼峰标识:单词之前使用_隔开
*/
//public static int HEADNUM = 1 ;
/* 抽象的方法 */
/**
* 抽象的方法,跑
*/
void run();
/* 丢人的写法 */
//public abstract void run1();
/* ====新特性开始 ==== */
/** * 有方法体的方法(普通的方法)
* 吃
* 要求:
* 必须被default修饰
* 此default和修饰符里面的default不一样
* 它是被public修饰
*/
default void eat() {
System.out.println("==IAnimal==eat");
}
/**
* 睡的方法
*/
default String sleep() {
System.out.println("==IAnimal==sleep");
return "===" ;
}
/* 静态的方法 */
static void staticMethod(){
System.out.println("==IAnimal==staticMethod");
}
/**
* 参数是一个接口;
* Supplier<IAnimal> supplier(供应商)
* @return
*/
static IAnimal createObj(Supplier<IAnimal> supplier) {
/* 让供应商去提供供货 */
return supplier.get() ;
}
/* ====新特性结束 ==== */
}
Person类
/**
* 人,是一个实现类
* 如果一个类实现一个接口,就要把接口中所有的抽象方法实现一遍
* 也可以实现接口中有方法体的方法(不能是静态方法)
*/
public class Person implements IAnimal{
@Override
public void run() {
System.out.println("==Person==run");
}
@Override
public void eat() {
/* 调用父类的方法 */
//IAnimal.super.eat();
System.out.println("==Person==eat");
}
}
Dog类
/**
* 狗
*/
public class Dog implements IAnimal{
@Override
public void run() {
System.out.println("==Dog==run");
}
}
测试类
/**
* 所有的程序的入口函数
*/
public class ClientMain{
public static void main(String[] args) {
System.out.println("==南宋中兴四将==");
/* 测试第一个
*父类引用指向子类对象
*/
IAnimal person = new Person();
/* 调用属性 */
int headNum = person.HEAD_NUM ;
System.out.println("==person.HEAD_NUM==" + headNum);
/* 接口名.属性 */
System.out.println("==IAnimal.HEAD_NUM==" + IAnimal.HEAD_NUM);
/* 调用方法 */
/* 调用抽象方法 */
person.run();
/*=====新知识======*/
/* 调用的是接口中有方法体的方法 */
person.eat();
person.sleep();
/* 调用的是接口中的静态方法 */
IAnimal.staticMethod();
/*==new对象==*///
IAnimal dog = new Dog();
/* Dog::new 调用的是Dog中的new方法
* ::调用方法的简写,左边是类名或者接口名,右边是方法名
* 返回值必须是functional Interface;(等讲到lambda表达式的时候再说)
* 必须有返回值
*/
IAnimal dog = IAnimal.createObj(Dog::new);
System.out.println("==createObj==" + dog);
IAnimal dog1 = Dog::new;
/* 调用方法
* 用::调用方法，返回值必须是functional Interface
* 必须有返回值类型
*/
//String res = dog::sleep;
}
}
2.Lambda
Lambda示例代码
import java.util.Date;
/**
* lambda的测试类
* 最终要实现的效果和匿名类很像
*/
public class LambdaMain{
public static void main(String[] args) {
System.out.println("====");
//lambdaAll();
System.out.println("==main开始==");
/* 创建线程并启动
* 接口中唯一的抽象方法
* public abstract void run();
* 最全的写法:它是唯一的抽象方法的简写
* (方法的形参) -> {方法体,如果有返回值,一定要写返回值}
* 最全的省略:
* 如果目标方法只有一个参数,可以省略小括号
* 小括号里面的形参:类型可以省略
* 如果方法体只有一行,大括号可以省略
* */
Thread t = new Thread( () -> System.out.println(Thread.currentThread() + "==计数=="+ "==" + new Date().toLocaleString()) );
t.start();
System.out.println("==main结束==");
}
/**
* 最全的写法(lambda)
* /
private static void lambdaAll() {
System.out.println("==main开始==");
/* 创建线程并启动
* 接口中唯一的抽象方法
* public abstract void run();
* 最全的写法:它是唯一的抽象方法的简写
* (方法的形参) -> {方法体,如果有返回值,一定要写返回值}
* 最全的省略:
* 如果目标方法只有一个参数,可以省略小括号
* 小括号里面的形参:类型可以省略
* 如果方法体只有一行,大括号可以省略
**/
Thread t = new Thread( () -> {
for (int i = 0; i < 10; i++){
System.out.println(Thread.currentThread() + "==计数=="+ i +"==" + new Date().toLocaleString());
try{
Thread.sleep(500);
} catch (InterruptedException e){
e.printStackTrace();
}
}
} );
t.start();
System.out.println("==main结束==");
}
}
Lambda表达式的示例代码
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
/**
* lambda的测试类 最终要实现的效果和匿名类很像
* 如果看到一个方法的参数类型后面跟了一个...
* 在方法定义的时候,把这三个点的参数,当成数组使用(String ... str)和(String[] str)效果一样
* 在方法使用的时候,这三个点要传入实参,实参的个数随便填写
* ...必须是方法形参的最后一个
* ~示例:方法调用时(String[] str)
* String[] str = {"1","2","3"} ;
* 目标方法(str)
* ~方法调用时String ... str
* 目标方法("1","2","3","3","3","3","3","3")
* @author TeaBig
*/
public class LambdaTest
{
public static void main(String[] args)
{
System.out.println("====");
/* 调用方法 */
String[] str = {"1","a","b","c","d"};
//method1Arr(str,"2");
/* 调用方法 */
//method2Point(str);
method2Point(1,"1","a","b","c","d","e");
/* 集合抽取lambda */
lambdaList();
}
/**
* lambda表达式,测试类
*/
private static void lambdaList()
{
/* 准备一个List */
List<String> list = Arrays.asList("1","a","b","c","d");
/* 如何循环
* void accept(T t);
* (类型忽略,直接写名字,形参名,名字随便写)
* */
// list.forEach( (t) ->
// {
// System.out.println("==lambda循环==" + t);
// } );
/* 超级简单的写法 */
list.forEach( t -> System.out.println("==lambda循环==" + t));
/* 匿名类
* 泛型是和容器的泛型一致
* */
list.forEach(new Consumer<String>()
{
@Override
public void accept(String t)
{
System.out.println("==Consumer循环==" + t) ;
}
});
}
/**
* 方法的形参是数组
* @param str
*/
public static void method1Arr(String[] str)
{
/* 查看数组里面的内容 */
for (int i = 0; i < str.length; i++)
{
String temp = str[i];
System.out.println(i + "==method1Arr==" + temp);
}
}
/**
* 方法的形参是三个点
* @param str
*/
public static void method2Point(int j , String... str)
{
/* 查看数组里面的内容 */
for (int i = 0; i < str.length; i++)
{
String temp = str[i];
System.out.println(i + "==method2Point==" + temp);
}
}
}
3.数据流编程
1.transformaction算子(方法的返回值还是Stream)
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;
import org.junit.Test;
/**
* 数据流编程
* @author TeaBig
*/
public class DataStream
{
/**
* 测试一个方法(框架)
*/
@Test
public void base()
{
/* 准备一个容器 */
List<Integer> intList = Arrays.asList(100,2,38,12,50,87);
/* 准备一个Stream */
Stream<Integer> souStream = null;
try
{
souStream = intList.stream();
/* 并行:多线程 */
//souStream = intList.parallelStream();
System.out.println("=isParallel==>" + souStream.isParallel());
/* 循环数据
* java.util.function.Consumer
* void accept(T t);
*
* forEach:action算子
* */
souStream.forEach( t -> System.out.println("==Stream循环==" + t));
} catch (Exception e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} finally
{
if(souStream != null)
{
souStream.close();
souStream = null ;
}
}
}
/**
* 过滤
* 按照指定的条件,对数据流里面的数据进行过滤
*/
@Test
public void transformaction_Filter()
{
/* 准备一个容器 */
List<Integer> intList = Arrays.asList(100,2,38,12,50,87);
/* 准备一个Stream */
Stream<Integer> souStream = intList.stream() ;
/* 过滤
* java.util.function.Predicate<T>
* boolean test(T t);
*
* 只有一行代码,return可以省略
* */
Stream<Integer> filterStream = souStream.filter( (t) -> t > 50);
/* 循环数据
* java.util.function.Consumer
* void accept(T t);
*
* forEach:action算子
* */
filterStream.forEach( t -> System.out.println("==Stream循环==" + t));
/* 关闭 */
souStream.close();
}
/**
* 过滤
*/
@Test
public void transformaction_Filter_Base()
{
/* 准备一个容器 */
List<Integer> intList = Arrays.asList(100,2,38,12,50,87);
/* 准备一个Stream */
Stream<Integer> souStream = intList.stream() ;
/* 过滤算子 */
Stream<Integer> filterStream = souStream.filter( new Predicate<Integer>()
{
@Override
public boolean test(Integer t)
{
System.out.println("=filter==test=" + t);
return t > 50;
}
} );
filterStream.forEach( new Consumer<Integer>()
{
@Override
public void accept(Integer t)
{
System.out.println("==循环==" + t);
}
} );
/* 关闭 */
souStream.close();
}
/**
* map算子
* 按照指定的条件,对数据流里面的数据进行处理(加工)
*/
@Test
public void transformaction_Map()
{
/* 准备一个容器 */
List<Integer> intList = Arrays.asList(100,2,38,12,50,87);
/* 准备一个Stream */
Stream<Integer> souStream = null;
try
{
souStream = intList.stream();
/* map算子;要把输入参数,经过一个方法变成另外一个参数;(处理参数)
* java.util.function.Function<T, R>
* R apply(T t);
*
* 需求:要把这里面的整数,都加一个字符串
* */
Stream<String> mapStream = souStream.map( (t) -> t + "==我变化了");
/* 循环数据
* java.util.function.Consumer
* void accept(T t);
*
* forEach:action算子
* */
mapStream.forEach( t -> System.out.println("==Stream循环==" + t));
} catch (Exception e)
{
// TODO Auto-generated catch block
e.printStackTrace();
} finally
{
if(souStream != null)
{
souStream.close();
souStream = null ;
}
}
}
/**
* FlatMap算子
* 它会对数据流里面的数据大小有要求
*/
@Test
public void transformaction_FlatMap()
{
/* 准备一个容器 */
List<String> strList = Arrays.asList("ab","cd","ef","test-hello-hadoop");
/* 准备一个Stream */
Stream<String> souStream = null;
try
{
souStream = strList.stream();
/* map算子;要把输入参数,经过一个方法变成另外一个参数;(处理参数)
* java.util.function.Function<T, R>
* R apply(T t);
*
* 需求:要把这里面的整数,都加一个字符串
*
* map的参数: Function<? super T, ? extends R> mapper;R木有要求
* flatMap的参数:Function<? super T, ? extends Stream<? extends R>> mapper;R要求必须是Stream;
* */
Stream<String> flatMapStream = souStream.flatMap( t ->
{
/（* 把字符串根据-拆分开 */
String[] splitList = t.split("-");
/* 返回值还是Stream这里面放的是字符串 */
List<String> tempList = Arrays.asList(splitList);
return tempList.stream() ;
});
/* 循环数据
* java.util.function.Consumer
* void accept(T t);
*
* forEach:action算子
* */
flatMapStream.forEach( t -> System.out.println("==Stream循环==" + t));
} catch (Exception e)
{
e.printStackTrace();
} finally
{
if(souStream != null)
{
souStream.close();
souStream = null ;
}
}
}
/**
* FlatMap算子
* 它会对数据流里面的数据大小有要求
*/
@Test
public void transformaction_other()
{
/* 准备一个容器 */
List<Integer> intList = Arrays.asList(100,2,50,50,50,87);
/* 准备一个Stream */
Stream<Integer> souStream = null;
try
{
souStream = intList.stream();
/*
* distinct:去重
* */
//Stream<Integer> stream = souStream.distinct();
/* 取前几条记录 */
//Stream<Integer> stream = souStream.limit(2);
/* 跳过前n条数据 */
//Stream<Integer> stream = souStream.skip(2);
/* 排序:默认升序 */
//Stream<Integer> stream = souStream.sorted();
/* java.util.Comparator<T>:
* int compare(T o1, T o2);
* */
//Stream<Integer> stream = souStream.sorted( (t1,t2) -> -(t1 - t2) );（）
Stream<Integer> stream = souStream.unordered();
/* 循环数据
* java.util.function.Consumer
* void accept(T t);
*
* forEach:action算子
* */
stream.forEach( t -> System.out.println("==Stream循环==" + t));
} catch (Exception e)
{
e.printStackTrace();
} finally
{
if(souStream != null)
{
souStream.close();
souStream = null ;
}
}
}
}
2.action算子(方法的返回值不是Stream)
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
import org.junit.Test;
/**
* 全是对一些action算子的测试
* @author TeaBig
*
*/
public class DataStreamAction
{
/**
* 数据流测试的基本代码
*/
@Test
public void base()
{
/* 准备一个List */
List<Integer> intList = Arrays.asList(100,2,38,12,50,87);
/* 准备一个Stream */
Stream<Integer> stream = intList.stream() ;
try
{
/* 循环 */
stream.forEach( t -> System.out.println("==循环==" + t));
}catch(Exception e)
{
if(stream != null)
{
/* 关闭 */
stream.close();
stream = null ;
}
}
}
/**
* 数据流测试的基本代码
* 数据流,只能碰到一个action算子
*数据流:
*一根管子,一个数据会把所有的管子走完以后,再走第二个数据;
*而不是所有的数据走完第一个管子以后,再一块走第二个管子
*/
@Test
public void other()
{
/* 准备一个List */
List<Integer> intList = Arrays.asList(1,2,3,4,5);
/* 准备一个Stream */
Stream<Integer> stream = intList.stream() ;
try
{
/* 把流里面的数据变成数组 */
// Object[] arrays = stream.toArray();
// System.out.println("==toString==>" + Arrays.toString(arrays));
/* 数据的数量 */
// long count = stream.count() ;
// System.out.println("==count==>" + count);
/* 查询第一个元素 */
// Optional<Integer> findFirst = stream.findFirst();
// System.out.println("==findFirst==>" + findFirst.get());
/* 获取到迭代器 */
// for (Iterator<Integer> iterator = stream.iterator(); iterator.hasNext();)
// {
// Integer intValue = (Integer) iterator.next();
// System.out.println("==循环==" + intValue);
// }
/* 获取最大值
* 先排序:(不管是升序还是降序,他始终认的是第一个)
* */
// Optional<Integer> maxOption = stream.max( (t1,t2) -> t1 - t2);
// System.out.println("==max=>" + maxOption.get());
/* 获取最小值 */
// Optional<Integer> minOption = stream.min( (t1,t2) -> t2 - t1);
// System.out.println("==min=>" + minOption.get());
/* 缩减
* 参数是:java.util.function.BinaryOperator<T>;得找有抽象方法的接口:
* java.util.function.BiFunction<T, U, R>
* 抽象方法是:R apply(T t, U u);
* 泛型T,U是输入参数,R是输出参数
* */
Optional<Integer> reduce = stream.reduce( (t1,t2) -> t1 + t2);
System.out.println("==reduce=>" + reduce.get());
}catch(Exception e)
{
if(stream != null)
{
/* 关闭 */
stream.close();
stream = null ;
}
}
}
}
数据流:
一根管子,一个数据会把所有的管子走完以后,再走第二个数据;
而不是所有的数据走完第一个管子以后,再一块走第二个管子
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
