java周记

一．使用Scanner
Scanner 就是一种引用类型，使用步骤如下：
1， 导包: import java,util.Scanner;
2， 创建：Scanner sc =new Scanner(System.in); (ps: 其中System.in 代表从键盘输入)
3， 使用：
a) 获取键盘输入的数字int : int num = sc.nextInt();
b) 获取键盘输入的字符 ： String str = sc.next();

二．使用数组
数组是引用类型 使用步骤如下：
1,数组的定义：
a） 数据类型[] 数组名称；
c) 数组类型 数组名称[];
2,数组的初始化：
a) 数据类型[] 数组名称 = new 数据类型 [数组长度]；
b) 数据类型[] 数组名称； 数组名称 = new 数据类型[数组长度];
3,数组的输出:
System.out.println(array[]);

三. 集合
1.什么叫做集合？
a)集合跟已经学过的数组比较类似，本身也是一种引用类型，本身也是一种引用类型，而且可以保存很多数据。
b)区别在于数组长度不可改变，集合的长度可以改变。
c)集合包含很多种，ArrayList ,HashSet ,LinkedList 等等，入门我们只学习ArrayList（是一种类）一种即可。
d)ArrayList（中括号代表泛型，统一的类型叫泛型）。

2.Java.util.ArrayList是一个类，使用起来就有三个步骤：
a)导包： import java.util.ArrayList
b)创建：ArrayList 常用构造方法：1.public Array List():默认无参数的构造方法。 ArrayList<泛型> list = new ArrayList<>()；(泛型：也就是集合当中存放的全是统一的什么类型的数据。注意: 泛型只能是引用类型数据不能是基本类型，如果一定要存储基本数据，那么就要使用基本类型对应的"包装类"，（全部都位于Java.lang 包下，有八种）
基本类型 对应的包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

)。

3.如何使用已经创建好的集合？
a)添加元素： public boolean add( E element) : 向集合当中添加一个元素，参数就是被添加的元素，而返回值是true值就代表成功。
b)获取元素：public E get(int index); 从集合当中获取一个元素，参数是元素索引。
c)获取长度：public int size(): 获取集合元素的个数，集合的长度，得到 int 数字。

package day2;

import java.util.ArrayList;

public class Demo {
public static void main(String[] args) {
	ArrayList<String> list1 = new ArrayList<>();//  构造集合。//泛型只能写引用类型，不能是基本类型。
	
	System.out.println(list1);//输出集合，此项并不是一个地址值 而是一对中括号。
	list1.add("鹿晗");//添加。下同。
	list1.add("赵丽颖");
	list1.add("吴亦凡");
	list1.add("张艺兴");
	System.out.println(list1);//打印集合。
	 Boolean success = list1.add("关小童");//集合返回的是Boolean 类型 因此success得到的的是true值。
	 System.out.println(success);
	 System.out.println(list1.get(2));//跟数组类似，这项得到的是集合的第二号元素。
	 System.out.println(list1.size());//得到集合的长度

}
}

遍历集合当中的所有字符串对象：

for(int i =0; i < list1.size(); i ++ )
	  {
		  String result = list1.get(i);
		  System.out.println(result);
	  }

4.添加基本类型：
代码如下：

ArrayList<Integer> list2 = new ArrayList<>();
	 list2.add(100);
	 list2.add(250);
	 System.out.println(list2);

基本类型可以和对应的包装类进行自动装箱拆箱：
装箱 ：基本类型 ——> 包装类。
拆箱 ：包装类——> 基本类型。

5.集合存储自定义类型对象
同String类似。

四. 接口

1.接口的基本定义格式：
public interface 接口名称{
1.抽象方法
2.常量
3.默认方法
4.静态方法
5.私有方法
}

2.接口定义抽象方法：
public abstract 返回值类型 方法名称（参数类型 参数名称）；
注意：a) 接口中的抽象方法，修饰符如果写必须写成：public abstract。
b)接口的抽象方法，修饰符可以省略不写，默认就是 public abstract。
c)抽象方法只有方法头, 不可能有方法大括号。

3.接口实现类的定义：
a)如果想要使用定义好的接口，必须有个接口的"实现类"： 定义实现类的格式为：public class 实现类的名称 implements 接口名称{
//一定要覆盖重写所有的抽象方法。
}

b)什么是覆盖重写抽象方法？
将接口当中的抽象方法抄写过来，去掉Abstract关键字，写上大括号方法体。

4.如何使用接口与实现类？
创建： 接口名称 引用名 =new 实现类名称（）；
调用： 引用名 . 抽象方法名（参数）；以下代码实现：

定义接口类：

package day2;

//接口类！！！
public interface Animal {
	public abstract void eat();
	public abstract void sleep();
	public abstract void speak();
	
}

package day2;

//实现类！！！
public class Cat  implements Animal{

	
	public void eat() {
		System.out.println("猫吃鱼！！！");
	}

	
	public void sleep() {
		System.out.println("猫睡觉！！！");
		
	}

	
	public void speak() {
		System.out.println("喵喵喵！！！");
		
	}

	public void catchMouse() //非接口抽象方法。
	{
		System.out.println("猫抓老鼠！！！");
	}
}

package day2;

//实现类！！！
public class Dog implements Animal {

	@Override
	public void eat() {
		System.out.println("狗吃骨头！！！");
	}

	
	public void sleep() {
		System.out.println("狗睡觉！！！");
		
	}

	
	public void speak() {
		System.out.println("汪汪汪！！！");
	}

}

package day2;
//方法的调用！！！
public class Demo {
public static void main(String[] args) {

	Animal cat = new Cat();//左边是接口类型，那么只能调用接口当中定义好的内容，不能调用右侧实现类当中特有的内容。（接口隔离）
	Animal dog =  new Dog();
	
	//调用接口中定义好的方法
	cat.eat();
	dog.eat();
	cat.catchMouse();//错误，非接口方法
	
}


}

5.面向接口编程
创建一个猫类。创建一个狗类。分别有吃饭睡觉等动作。运用接口，用一个方法输出。
见代码：

package day2;
//方法的调用！！！
public class Demo {
public static void main(String[] args) {

	Animal cat = new Cat();//左边是接口类型，那么只能调用接口当中定义好的内容，不能调用右侧实现类当中特有的内容。（接口隔离）
	Animal dog =  new Dog();
	
	//调用接口中定义好的方法
	cat.eat();
	dog.eat();
	method(cat);//将猫对象传递给方法，间接使用其中的eat(), sleep()方法。	
	method(dog);
}

public static void method(Animal animal)//使用接口作为参数类型，这样就不区分到底是猫是狗。
{
	
	animal.eat();
	animal.sleep();
	animal.catchMouse(); //错误！！！无法调用猫的专用方法
	
}



}

6.Lambda表达式
初步理解：先看问题：通过调用接口实现两个数相加。
面向对象代码如下：

package day1;

public interface Calculator {
	int sum(int a,int b);
}

package day1;

public class Cal implements Calculator {
	public int sum(int a, int b) {
		return a + b;
	}
}

package day1;

public class Main {
 public static void main(String[] args) {
	Calculator cal = new Cal();
	method(cal);
}
 public static void method(Calculator calculator)
 {
	 int result = calculator.sum(100,200);
	 System.out.println("结果是：" + result);
 }
}

但是使用Lambda表达式可以使结构更加简单：

package day2;

public interface Calculator {
	int sum(int a , int b);

}

package day2;

public class Main {
	public static void main(String[] args) {
		method((x,y) -> x + y);
	}
	
 public static void method(Calculator calculator )
 {
	 int result = calculator. sum(100,200);
	 System.out.println("结果是：" + result);
 }
}

a）Lambda表达式： （x , y）->x + y;
b) method 方法需要一个Calculator接口类型的参数，Lambda表达式就充当了Calculator接口类型的参数。
c)对表达式的初步理解：Lambda前面的小括号其实就是接口抽象方法的小括号。箭头代表拿着小括号做什么事，是指向一个动作。箭头后 面的就代表拿了参数做什么事情。Lambda表达式的语义本身就代表了怎么做这件事，没有对象的概念在里面。（更加简单直观），但是接口抽象方法只能有一个。
d)函数式接口：有且仅有一个抽象方法的接口叫做函数式接口。如何才能万无一失检测一下当前接口是不是函数接口？：
用一固定格式写在、public interface 之前一行即可：

package day2;
@FunctionalInterface
public interface Calculator {
	int sum(int a , int b);

}

7.获取Stream流的常用方式
a) Java 8 当中的流其实就是Stream接口对象。 JDK提供一个流接口：java.util.stream.Stream
b)如何获取流？
（1）.根据集合获取流：集合名称.stream（）；
（2）.根据数组获取流：Stream.of(数组名称)；

package day3;

import java.util.ArrayList;
import java.util.stream.Stream;

public class GetStream {
	public static void main(String[] args) {
		//根据集合获取流；
		ArrayList<String> list = new ArrayList<>();
		list.add("迪丽热巴");
		list.add("古丽拉扎");
		list.add("马尔扎哈");
		list.add("德玛西亚");
		//根据集合获取流：
		Stream<String> streamA  =  list.stream();
		//根据数组获取流
		String[] arrayStr = {"Hello","world","Java"};
		Stream<String> streamB = Stream.of(arrayStr);
		Integer[] arrayInteger = {1,2,3,4};
		//获取整数流
		Stream<Integer> streamC = Stream.of(arrayInteger); 
	}

}

既然获取了流，那我们就要输出流。如何输出流呢？这里通过map映射方法输出流。
获取流之后，可以使用映射方法：map(用于转换的Lambda表达式。映射：就是将一个对象转换成为另一个对象，把老对象映射到新对象上。）