发布于2021-03-10 18:12 阅读(751) 评论(0) 点赞(4) 收藏(5)
jdk(java development kit),即Java开发工具集。
jre(java runtime enviroment),即Java运行环境
jvm(java virtual machine),Java虚拟机。目前主要使用的式hotsopt。
Green项目
应用环境:像电视盒这样的消费类电子产品
要求:
发明者:James Gosling
历程:
▪ 1991年,Sun公司的Green项目,Oak
▪ 1995年,推出Java测试版
▪ 1996年,JDK1.0
▪ 1997年,JDK1.1
▪ 1998年,JDK1.2,大大改进了早期版本的缺陷,是一个革命性的版本,更名为Java2
▪ 1999 Java被分成J2SE、J2EE 和J2ME,JSP/Servlet技术诞生
▪ 2004年,J2SE 5.0 (1.5.0) Tiger老虎.为了表示这个版本的重要性,J2SE1.5更名为J2SE5.0。
▪ 2006年,J2SE 6.0 (1.6.0) Mustang野马.此时,Java的各种版本被更名,取消其中的数字"2":J2EE更名为Java EE, J2SE更名为
Java SE,J2ME更名为Java ME
▪ 2009年4月20日甲骨文收购Sun公司,交易价格达74亿美元
▪ 2011年,JavaSE7.0
▪ 2014年 ,JavaSE8.0
▪ 2017年,JavaSE9.0
▪ 2018年3月,JavaSE10.0
▪ 2018年9月,JavaSE11.0
▪ 2019年3月,JavaSE12.0
public class Test{
public static void main(String[] args){
System.out.println("hello, world");
}
}
用来给类、变量、方法、对象等起的名称。因为在Java中一切皆对象,故不存在函数这一说,只有方法。
首字母可以是字母、下划线、美元符号,但是不能是数字
// 合法
int a;
int _a;
int A;
int $a;
// 不合法
int 1a;
其他部分只能是字母、下划线、数字、美元符号
// 合法
int a1_$;
// 不合法
int a-1;
Java严格区分大小写
int a;
int A;
// a和A不是同一个变量
Java命名变量的时候建议采用驼峰标识以及变量要见名知意
// 建议
String name;
int age;
boolean isAlive;
// 不建议
String s;
int a;
boolean b;
给系统使用的关键字,比如:int,float,void, class,for,while,break等等,在定义变量的时候不能定义成:int float;
。
算术运算符包括:+,-,*,/,%。
int a = 10;
int b = 3;
a + b; // 13
a - b; // 7
a * b; // 30
a / b; // 作商, 3
a % b; // 取余, 1
比较运算符包括:==,!=,>,>=,<, <=。
int a = 10;
int b = 3;
a == b; // false
a != b; // true
a > b ; // true
a >= b; // true
a < b ; // false
a <= b; // false
赋值运算符:int a = 10;
,将10赋值给变量a。
逻辑运算符包括:&&,||,!。
int a = 10;
int b = 1;
int c = 2;
// && 两边同时为true结果返回true,否则返回false
(a > b) && (a > c); // true,a>b为true,a>c为true
(a > b) && (a < c); // false, 因为,a>b为true,a<c为fasle
// || 两边只要有一边为true,结果返回true
(a > b) || (a > c); // true,a>b为true,a>c为true
(a > b) || (a < c); // true,a>b为true,a<c为false
(a < b) || (a > c); // true,a<b为false,a>c为true
(a < b) || (a < c); // false,a<b为fasle,a<c为false
// !,对取得的布尔值取反操作,!true->false, !false->true
!(a>c); // fasle,a>c为true
// &&,|| 的短路操作
(a > b) && ((c = b) ==b); // true,c=1,因为a>b为true,继续比较右边,执行右边
(a < b) && ((c=b)==b); // false,c=2,因为a<b为false,直接返回false,不比较后面代码,也不执行后面代码
(a > b) || ((c=b)==b); // true,c=2,因为a>b为true,直接返回结果,不执行后面操作
(a < b) || ((c=b)==b); // true,c=1,因为a<b为false,继续比较右边,执行右边代码,右边结果为true
形如:xxx?x:y。若xxx语句的返回值为true,则返回x,否则返回y。
int a = 10>20?1:2; // a=2,因为10>20为false
位运算符主要包括:&,|,^。
// & 将两个数转换为二进制进行比较,相同的位上都是1,则该位比较后的值为1
// | 将两个数转换为二进制进行比较,相同的位上如果存在1,则该位比较后的值为1
// ^ 将两个数转换为二进制进行比较,相同的位上如果存在1,且不同时为1,则该位比较后的值为1
5转换成二进制:0101
3转换成二进制:0011
0101
& 0011
= 0001 转换成10进制:1
0101
| 0011
= 0111 转换成10进制:7
0101
^ 0011
= 0110 转换成10进制:6
byte b;
short s;
int i;
long l;
float f;
double d;
char c;
boolean b;
String string;
占1位。
String
数组
定义方式
int[] numbers = new int[10]
;int[] numbers = new int[10]{1,2,3,4,5,6,7,8,9,0};
int[] numbers = {1,2,3,4,5,6,7,8,9,0};
使用
获取
int[] numbers = {1,2,3};
System.out.println(numbers[1]);
修改
int[] numbers = {1,2,3};
numbers[1] = 10;
注意:
对象
类的实例化
class Person{
}
Person person = new Person();
// person即为对象
接口
某种行为/功能的抽象,若要使用则要实现接口中的所有方法,接口类似于一种约束、规范
interface MyInterface{
void method();
}
等等
从上到下依次按顺序执行
if
if(条件){
执行语句
}
// 但条件的返回结果为true时执行执行语句,否则不执行
// 应用
int a = 10;
if(a < 20){
a = 30;
}
// 因为 a<20为true,执行语句,a=30
if...else
if(条件){
执行语句
}else{
执行语句2
}
// 若条件的返回结果为true,则执行语句,否则执行语句2
// 应用
int a = 10;
if(a>10){
a = 8;
}else{
a = 20;
}
// 因为a>10为false,因此执行a=20
if...else if...else
if(条件1){
执行语句1
}else if(条件2){
执行语句2
}else{
执行语句3
}
// 若满足条件1,则执行语句1,否则若满足条件2,则执行语句2,否则执行语句3
// 应用
int a = 10;
if(a > 10){
a = 8;
}else if(a > 5){
a = 4
}else{
a = 100;
}
//a = 4,因为a>10为false,a>5为false,执行a=4
switch
switch(变量){
case value1:
执行语句1
break;
case value2:
执行语句2
break;
default:
执行语句3
break;
}
// 变量的值如果等于某一个case后面的值则执行相应的语句,然后跳出语句,否则就执行default里的语句,然后退出
// 这里变量以及case的值只能为:整数、字符、字符串
// 应用
int a = 10;
switch(a){
case 10:
System.out.println("10");
break;
case 20:
System.out.println("20");
break;
default:
System.out.println("no");
break;
}
// 打印10
do...while
do{
执行语句
}while(条件);
// 循环执行语句,直到不满足条件,至少做一次
int a = 0;
do{
System.out.print(i);
i++;
}while(i<20);
while
while(条件){
执行语句
}
// 但满足条件时循环执行语句,直到不满足条件
int a = 0;
while(a < 10){
System.out.println(a);
a++;
}
for
for(初始化变量;满足的条件;更新变量){
执行语句
}
// 对于初始化变量,每次执行语句后更新变量,直到不满足条件
for(int a;a<10;a++){
System.out.println(a);
}
增强for循环
对于一个集合、数组或者map,若其中的元素的类型都一致,则可以使用使用forech(增强for循环来遍历)
for(类型 变量:集合){
执行语句
}
// 应用
int[] numbers = {1,2,3,4,5};
for(int number:numbers){
System.out.println(number);
}
break
跳出当前循环
for(int i=0;i<10;i++){
if(i==5){
break;
}
System.out.println(i);
}
//打印0-4后,更新变量,i=5,此时跳出for循环
continue
跳过本次循环
for(int i=0;i<10;i++){
if(i % 2 !=0){
continue;
}
System.out.println(i);
}
// 打印0-9所有的偶数
return
返回结果值
public int addOne(int number){
return number + 1;
}
System.out.println(addOne(10));
// 返回11
结束程序
for(int i=0;i<10;i++){
if(i ==5){
return;
}
}
// 当i==5时,结束程序
典型的是C语言。通过分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。以把大象放入冰箱为例,我们首先定义一个拿到大象的函数,然后定义一个开冰箱的函数,然后定义一个放大象的函数,然后定义一个关冰箱的函数,最后一次调用就可以实现功能了。
在考虑问题时,以一个具体的流程(事务过程)为单位,考虑它的实现。
典型的C++、C#、Java等编程语言。通过将现实世界中的物体抽象成一个具体的类,通过调用类的相关方法来完成一系列行为。还是以把大象放入冰箱为例,我们先定义一个人的类,有拿大象、放大象、开冰箱、关冰箱的方法(也就是人可以做这些事情),再定义一个大象类,再定义一个冰箱类,然后创建相应的对象调用相关的方法即可。
在考虑问题时,以对象为单位,考虑它的属性及方法。
定义(规范,约束)与实现(名实分离的原则)的分离。
接口的本身反映了系统设计人员对系统的抽象理解。
通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
典型的是Python、JavaScript语言。
函数式编程是种编程方式,它将电脑运算视为函数的计算。函数编程语言最重要的基础是λ演算(lambda calculus),而且λ演算的函数可以接受函数当作输入(参数)和输出(返回值)。主要思想是把运算过程尽量写成一系列嵌套的函数调用。
在现实生活中,人(Person)表示一种生物,很抽象,具体的人:张三,就是一个对象,一个具体的人,一个独立的个体。
// 定义一个类
class Person{
}
// 实例化一个对象(创建一个对象)
Person zhangsan = new Person();
通过new关键字实现。
一个类的构造方法,用于对一个对象的初始化,比如说我们在买电脑的时候都会选择电脑的:cpu、内存、硬盘、显示屏等等,这些相当于初始化。
class Computer{
private String cpu;
private String arm;
private String disk;
private String screen;
public Computer(String _cpu, String _arm, String _disk, String _screen){
cpu = _cpu;
arm = _arm;
disk = _disk;
screen = _screen;
}
}
// 利用构造器创建对象
Computer myComputer = new Computer("Intel", "英伟达","sanxing", "英伟达");
默认情况下建议写一个无参构造器。
指代当前对象。可以在构造方法中使用,用来区分参数和成员变量,在普通方法中使用表示调用当前的属性或者当前类的方法,可以省略。
class Computer{
private String cpu;
private String arm;
private String disk;
private String screen;
public Computer(String cpu, String arm, String disk, String screen){
this.cpu = cpu;
this.arm = arm;
this.disk = disk;
this.screen = screen;
}
}
// 利用构造器创建对象
Computer myComputer = new Computer("Intel", "英伟达","sanxing", "英伟达");
表示静态的,更准确的说是表示类的什么什么,被static修饰的方法、函数、类(内部类)在类加载的时候就创建了,而没有被修饰的则是属于对象,只有当创建对象的时候才创建,因为,static修饰的属性、方法、类的创建是先于普通属性、方法的,因此:静态方法中不能存在普通的属性、方法、对象。
被static修饰的属性、方法,类可以直接调用。
class Person{
static boolean isPerson = true;
static void sleep(){
}
}
// 调用
System.out.println(Person.isPerson);
System.out.println(Person.sleep());
表示最终的,不可更改,有三种形式
打包:区分同名的文件,分布在不同的目录。
将不同的功能代码整合在一起。
导包:方便引用其他包的类
规定方法、类、属性的访问范围。
分类:
在同一个类中,可以定义多个同名方法,但是,这些方法必须满足以下三个条件之一:
参数类型不一样
参数个数不一样
参数顺序不一样
class Demo{
public void method(){
}
public void method(String str){
}
public void method(String str,int number){
}
public void method(int number,String name){
}
}
在代码中可以将某个代码块变成方法,抽象出某些工具类
public class Test2 {
private String string;
private int number;
public String getString() {
return string;
}
public void setString(String string) {
this.string = string;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
}
解释说明
重写
super
public class Test2 extends Test4{
@Override
public void method() {
super.method1();
System.out.println("Test2->method");
}
}
class Test4{
public void method(){
System.out.println("Test4->method");
}
public void method1(){
System.out.println("Test4->method1");
}
}
public class Test2{
public static void main(String[] args) {
personSpeak(new Boy()); // 传入子类自动转换成父类
personSpeak(new Girl());
personSpeak((Person) new Object()); // 父类到子类强制转换,Object类是所有类的父类
}
static void personSpeak(Person person){
person.speak();
}
}
abstract class Person{
abstract void speak();
}
class Boy extends Person{
@Override
void speak() { // 重写父类方法
System.out.println("男孩说话");
}
}
class Girl extends Person{
@Override
void speak() {
System.out.println("女孩说话");
}
}
public class Test2{
public static void main(String[] args) {
new Singer().singSong(new Boy());
}
}
interface Sing{
final boolean isSing = true;
void singSong(Person person);
}
class Singer extends Person implements Sing{
@Override
public void singSong(Person person) {
this.speak();
}
@Override
void speak() {
}
}
// 案例:人都要睡觉;人要说话,但是不同国家的人说的话不一样,中国人说中文,美国人说美语
abstract class Person{
public void sleep(){
System.out.println("是个人都睡觉");
}
abstract void speak();
}
class Chinese extends Person{
@Override
void speak() {
System.out.println("中国人说作文");
}
}
class American extends Person{
@Override
void speak() {
System.out.println("美国人说美语");
}
}
public class Demo1 {
public static void main(String[] args) {
// 静态内部类
StaticInnerClass staticInnerClass = new Demo1.StaticInnerClass();
// 成员内部类
InnerClass innerClass = new Demo1().new InnerClass();
// 方法内部类,生命周期指在方法内
Object o = method();
// 匿名内部类
MyInterface myInterface = new MyInterface() {};
}
static class StaticInnerClass{
}
class InnerClass{
}
public static Object method(){
class MethodInnerClass{
}
return new MethodInnerClass();
}
}
interface MyInterface{
}
表示程序在运行过程中出现的非正常情况,编写代码的过程中尽可能少的减少异常出现的情况
try...catch
try{
可能出现异常的语句
}catch(可能出现的异常){
捕捉异常后执行的语句
}
//
try{
int x = 1 /0;
}catch(ArithmeticException e){
e.printStack();
}
try...catch...finally
try{
可能发生异常的代码
}catch(发生的异常){
捕捉异常后执行的语句
}finally{
不管是否发生异常都要执行的语句
}
//
try{
int x = 1 /0;
}catch(ArithmeticException e){
e.printStack();
}finally{
System.out.println("finally")
}
注意
当发生异常时,在try代码块中异常语句后面的语句不会再执行
try、catch、finally以及try...catch...finally之外的代码是互相独立的,在try中定义的变量在其他的部分无法访问,改变了仅作用于try部分,其他catch、finally情况类似,但是外部定义的变量在try、catch、finally中可以使用
在进行异常捕获的时候,return语句的不同位置会造成结果的不同
首先讨论try...catch...finally后面有代码的情况
//此时注意一个关键的点:checked异常,即return语句后面不能再跟语句
// 例如
return;
System.out.println("after return");// 这条语句ide直接报错,相当于多余的
// 故return的语句只能有一下几种情况
//1
try{
System.out.println("1");
System.out.println(1 / 0);
return;
}catch (Exception e){
System.out.println("2");
// return;
}finally {
System.out.println("3");
// return;
}
System.out.println("4");
}
// 此时return语句永远都不会被执行,也就不会报错。
//2
try{
System.out.println("1");
// System.out.println(1 / 0);
return;
}catch (Exception e){
System.out.println("2");
// return;
}finally {
System.out.println("3");
// return;
}
System.out.println("4");
//此时,当程序执行到return语句时,并不会立即执行,而是先挂起,等执行完finally中的语句之后再执行return语句结束程序,故try、catch、finally之外的其他代码不会再执行
//其他的catch、finally中都不能再存在return语句了
try...catch...finally后面没有代码的情况
//第一种情况
try{
System.out.println("1");
System.out.println(1 / 0);
return;
}catch (Exception e){
System.out.println("2");
// return;
}finally {
System.out.println("3");
// return;
}
// 此时return语句永远不会执行
// 第二种情况,此时return语句有没有都没有关系
try{
System.out.println("1");
// System.out.println(1 / 0);
return;
}catch (Exception e){
System.out.println("2");
// return;
}finally {
System.out.println("3");
// return;
}
//第三种情况
try{
System.out.println("1");
System.out.println(1 / 0);
// return;
}catch (Exception e){
System.out.println("2");
return;
}finally {
System.out.println("3");
// return;
}
//此时,还是跟前面一样的,return先挂起,执行完finally中的代码后再结束程序
//第三种情况
public class Demo {
public static void main(String[] args) {
System.out.println(method());
}
public static int method(){
try{
System.out.println("1");
System.out.println(1 / 0);
// return;
}catch (Exception e){
System.out.println("2");
return 1;
}finally {
System.out.println("3");
// return 2;
}
// System.out.println("4");
return 0;
}
}
// 此时会执行最近的return语句
综上:
将异常情况抛出给调用者
注意,如果整个程序的运行过程中都没有异常的处理的话,最终异常会抛给jvm,不太友好,一般都要对异常进行处理
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class Demo1 {
public static void main(String[] args) throws FileNotFoundException {
FileInputStream fileInputStream = new FileInputStream("test.txt");
}
}
java中提供了非常多的异常类,但是在某些项目中需要自己定义独特的异常处理方式,此时需要自定义异常
public class MyException extends Exception{
public MyException(){
System.out.println("自定义异常");
}
}
public class Demo1 {
public static void main(String[] args) throws MyException {
throw new MyException();
}
}
另外,还可以自定义异常信息
public class Demo1 {
public static void main(String[] args) throws Exception {
throw new Exception("test");
}
}
基本数据类型都由对应的包装类
自动拆箱和自动装箱
举例
public class Demo {
public static void main(String[] args) {
// 此时自动调用:Integer.valueOf(),若数字大于-128且小于127,直接返回值,否则新建一个对象
Integer integer1 = 1000;
Integer integer2 = 1000;
int i1 = 1000;
int i2 = 1000;
System.out.println(integer1 == integer2); // 因为两个变量不是同一个对象因此结果为false
System.out.println(integer1.equals(integer2));// true
System.out.println(i1 == i2); // true
System.out.println(i1 == integer2); // true
}
}
不可变字符串:String
可变字符串:
举例
public class Demo1 {
public static void main(String[] args) {
StringBuffer stringBuffer = new StringBuffer("hello,world");
// 增
stringBuffer.insert(0, "@");
stringBuffer.append("#");
// 删
stringBuffer.delete(0,1);
// 改
stringBuffer.setCharAt(0, '$');
stringBuffer.replace(0,1,"x");
// 查
stringBuffer.indexOf("a");
stringBuffer.substring(0,1);
System.out.println(stringBuffer);
}
}
日期常用类
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo2 {
public static void main(String[] args) {
DateFormat dateFormat = new SimpleDateFormat("YY-MM-dd HH-mm-ss"); // 创建格式化日期类
System.out.println(dateFormat.format(new Date()));
}
}
返回格林威治时间
import java.util.Calendar;
import java.util.GregorianCalendar;
public class Demo3 {
public static void main(String[] args) {
Calendar calendar = new GregorianCalendar();
System.out.println(calendar.getTime());
System.out.println(calendar.getTimeZone());
System.out.println(calendar.getFirstDayOfWeek());
System.out.println(calendar.getWeekYear());
}
}
数学常用类
public class Demo4 {
public static void main(String[] args) {
System.out.println(Math.max(10,20));
System.out.println(Math.abs(-1));
System.out.println(Math.ceil(1.1));
System.out.println(Math.PI);
System.out.println(Math.E);
}
}
import java.util.Random;
public class Demo5 {
public static void main(String[] args) {
System.out.println(new Random().nextInt(10));
System.out.println(new Random().nextDouble());
}
}
枚举类也是一个类,可以定义属性和方法,甚至可以写构造方法,填写具体的枚举类对象的时候,可以带参数,但是要跟构造方法进行匹配
public class Demo6 {
public static void main(String[] args) {
System.out.println(Gender.FEMALE);
}
}
public enum Gender {
MALE,FEMALE;
}
每个枚举的子枚举都可以看作是枚举的子类,可以定义相关方法以及相应的set/get方法来获取子枚举携带的一些信息
public enum WEEK_DAY {
MONDAY(0),
TUESDAY(1),
WEDNESDAY(2),
THURSDAY(3),
FRIDAY(4),
SATURDAY(5),
SUNDAY(6);
private int value;
public void method(int i){
System.out.println(i);
}
public int getValue(){
return this.value;
}
WEEK_DAY(int i) {
this.value = i;
}
}
public class Demo6 {
public static void main(String[] args) {
System.out.println(WEEK_DAY.FRIDAY.getValue());
}
}
一个用来储存数据的容器
形如:int[],String[]
的数据结构
特点:
具有的基本操作:
不唯一,有序
ArrayList实现了长度可变的数组,在内存中分配连续的空间
LinkedList采用链表存储方式
LinkedList特有方法
采用Hashtable哈希表存储结构
优点:添加速度快,查询速度快,删除速度快
缺点:无序
LinkedHashSet
关键代码
HashSet hs=new HashSet();//创建HashSet对象
hs.add(new Person("张三",20));
hs.add(new Person("李四",22));
hs.add(new Person("王五",23));
hs.add(new Person("李四",22));
@Override
public int hashCode() {
System.out.println(this.name+".....hashCode");
return 60;
}
hashCode都相同,不符合实际情况,继续升级
修改hashCode方法
@Override
public int hashCode() {
System.out.println(this.name+".....hashCode");
return this.name.hashCode()+age;
}
总结:
所有可以“排序”的类都实现了java.lang.Comparable 接口 compareTo(Object obj) 方法。
该方法:
返回 0 表示 this == obj
返回正数 表示 this > obj
返回负数 表示 this < obj
实现了Comparable 接口的类通过实现 comparaTo 方法从而确定该类对象的排序方式。
public class StrLenComparator implements Comparator<String> {
@Override
public int compare(String o1, String o2) {
if (o1.length()>o2.length()) {
return 1;
}
if (o1.length()<o2.length()) {
return -1;
}
return o1.compareTo(o2);//长度相同, 按字母
}
}
public static void sortDemo(){
List<String> list=new ArrayList<String>();
..添加元素
sop(list);
Collections.sort(list);//按字母排序
sop(list);
//按照字符串长度排序
Collections.sort(list,new StrLenComparator());
sop(list);
}
所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现了Iterator接口的对象。
Iterator对象称作迭代器,用以方便的实现对容器内元素的遍历操作。
Iterator接口定义了如下方法:
boolean hasNext(); //判断是否有元素没有被遍历
Object next(); //返回游标当前位置的元素并将游标移动到下一个位置
void remove(); //删除游标左面的元素,在执行完next之后该
//操作只能执行一次
所有的集合类均未提供相应的遍历方法,而是把遍历交给迭代器完成。迭代器为集合而生,与门实现集合遍历
Iterator是迭代器设计模式的具体实现
Iterator方法:
可以使用Iterator遍历的本质 :实现Iterable接口
在迭代过程中,准备添加或者删除元素
ArrayList al=new ArrayList();
al.add("java1");//添加元素
al.add("java2");
al.add("java3");
//遍历
Iterator it=al.iterator();
while(it.hasNext()){
Object obj=it.next();
if (obj.equals("java2")) {
al.add("java9");
}
sop("obj="+obj);
}
在迭代时,不可能通过集合对象的方法(al.add(?))操作集合中的元素,会发生并发修改异常。 所以,在迭代时只能通过迭代器的方法操作元素,但是Iterator的方法是有限的,只能进行判断(hasNext),取出(next),删除(remove)的操作,如果想要在迭代的过程中进行向集合中添加,修改元素等就需要使用 ListIterator接口中的方法
ListIterator li=al.listIterator();
while(li.hasNext()){
Object obj=li.next();
if ("java2".equals(obj)) {
li.add("java9994");
li.set("java002");
}
}
接口存储一组键值对象,提供key到value的映射
Collections和Collection不同,前者是集合的操作类,后者是集合接口
Collections提供的静态方法 :
数组不是面向对象的,存在明显的缺陷,集合弥补了数组的一些缺点,比数组更灵活更实用,可大大提高软件的开发效率,而且不同的集合框架类可适用不同场合。具体如下:
实现原理相同,功能相同,底层都是哈希表结构,查询速度快,在很多情况下可以互用
两者的主要区别如下 :
流是指一连串流动的字符,是以先进先出方式发送信息的通道 。
XXX->程序-->输入流
程序->XXX-->输出流
输入输出流是相对于计算机内存来说的,而不是相对于源和目标
字节流是 8 位通用字节流,字符流是 16 位 Unicode 字符流
功能不同
节点流:可以直接从数据源或目的地读写数据
处理流(包装流):不直接连接到数据源或目的地,是其他流进行封装。目的主要是简化操作和提高性能
节点流和处理流的关系
节点流处于io操作的第一线,所有操作必须通过他们进行
处理流可以对其他流进行处理(提高效率或操作灵活性)
用FileInputStream和FileOutputStream读写文本文件
使用FileInputStream 读文本文件
引入相关的类
构造文件输入流FileInputStream对象
读取文本文件的数据
关闭文件流对象
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Demo {
public static void main(String[] args) {
FileInputStream fileInputStream;
byte[] bytes = new byte[1024];
try {
fileInputStream= new FileInputStream("test.txt");
fileInputStream.read(bytes);
System.out.println(new String(bytes));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
fileInputStream.close();
}
}
使用FileOutputStream 写文本文件
引入相关的类
构造文件数据 流输出对象
将数据写入文 本文件
关闭文件流对象
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class Demo2 {
public static void main(String[] args) throws IOException {
FileOutputStream fileOutputStream = new FileOutputStream("test.txt");
String string = "aaaaa";
fileOutputStream.write(string.getBytes(StandardCharsets.UTF_8));
fileOutputStream.close();
}
}
用BufferedReader和BufferedWriter读写文本文件
使用 BufferedReader 读文本文件
import java.io.*;
public class Demo3 {
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("test.txt");
BufferedReader bufferedReader = new BufferedReader(fileReader);
String result = "";
while ((result = bufferedReader.readLine())!=null){
System.out.println(result);
}
bufferedReader.close();
fileReader.close();
}
}
使用 BufferedWriter 写文件
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class Demo4 {
public static void main(String[] args) throws IOException {
FileWriter fileWriter = new FileWriter("test.txt");
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
String string = "aaaaaaaa\naaaaaa\taaaa\nsdsdsds";
bufferedWriter.write(string);
bufferedWriter.close();
fileWriter.close();
}
}
使用DataInputStream和DataOutputStream读写二进制文件以及基本数据类型数据的读写
写入数据
DataOutputStream dos=new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeInt(234);
dos.writeBoolean(false);
dos.writeDouble(9943.00);
dos.writeUTF("中国");
dos.close();
读取数据
DataInputStream dis=new DataInputStream(new FileInputStream("data.txt"));
int num=dis.readInt();
boolean isFind=dis.readBoolean();
double price=dis.readDouble();
String str=dis.readUTF();
System.out.println(num+"\t"+isFind+"\t"+price+"\t"+str);
使用ObjectInputStream和ObjectOutputStream读写对象(序列化与反序列化)
注意:传输的对象需要实现Serializable接口
序列化
ObjectOutputStream oos=new ObjectOutputStream(new
FileOutputStream("obj.txt"));
oos.writeObject(new Person("张三",19));
oos.close();
反序列化
ObjectInputStream ois=new ObjectInputStream(new
FileInputStream("obj.txt"));
Person p=(Person)ois.readObject();
System.out.println(p);
注意:
在Java中负责线程的这个功能的是Java.lang.Thread 这个类
可以通过创建 Thread 的实例来创建新的线程
每个线程都是通过某个特定Thread对象所对应的方法run( )来完成其操作的,方法run( )称为线程体
通过调用Thead类的start()方法来启动一个线程
具体实现:
public class ThreadDemo01 extends Thread {
//重写父为的run方法
@Override
public void run() {
for(int i=0;i<10;i++){
System.out.println("第"+i+"次threadrun........");
}
}
public static void main(String[] args) {
//创建对象,就创建好一个线程
ThreadDemo01 d=new ThreadDemo01();
//d.run();//启动线程使用start方法
d.start();
for(int i=0;i<5;i++){
System.out.println("main-->"+i);
}
}
}
线程的执行
操作步骤
public class RunableDemo implements Runnable {
@Override
public void run() {
for(int i=0;i<10;i++){
System.out.println("第"+i+"次threadrun........");
}
}
public static void main(String[] args) {
//创建对象,就创建好一个线程
RunableDemo rd=new RunableDemo();
Thread t=new Thread(rd);
t.start();
for(int i=0;i<5;i++){
System.out.println("main-->"+i);
}
} }
有三种方法可以暂停Thread执行:
public class TicketImplements implements Runnable {
private int tick=5;
public void run() {
while(true){
if (tick>0) {
Thread.sleep(10);
System.out.println(Thread.currentThread().getName()+"卖票:"+tick--);
}
}
}
public static void main(String[] args) {
TicketImplements ti=new TicketImplements();
new Thread(ti).start();
new Thread(ti).start();
new Thread(ti).start();
new Thread(ti).start();
}
多线程的运行出现了安全问题
使用同步解决多线程的安全性问题
同步代码块
public void run() {
while(true){
synchronized (this) {//通常将当前对象作为同步对象
if (tick>0) {
Thread.sleep(10);
System.out.println(Thread.currentThread().getName()+"卖
票:"+tick--);
}
}
}
}
同步的前提
将需要同步的代码放到方法中
public void run() {
while(true){
sale();
}
}
public synchronized void sale(){
//通常将当前对象作为同步对象
if (tick>0) {
Thread.sleep(10);
System.out.println(Thread.currentThread().getName()+"卖票:"+tick--);
}
}
同步监视器
同步监视器的执行过程
Java提供了3个方法解决线程之间的通信问题
一组相互连接的计算机
OSI参考模式:开放系统互连参考模型(Open System Interconnect)
TCP/IP参考模型:传输控制/网际协议 Transfer Controln Protocol/Internet Protocol
获得百度主机名:
InetAddress ia2=InetAddress.getByName("www.baidu.com");
System.out.println("其它主机名称:"+ia2.getHostAddress());
进行网络通信时, Socket需要借助数据流来完成数据的传递工作
客户端
Socket socket=new Socket("localhost",8800);
OutputStream os=socket.getOutputStream();
String info="用户名: Tom;用户密码: 123456";
os.write(info.getBytes());
socket.shutdownOutput();
关闭所有的数据流和Socket
os.close();
socket.close();
服务端
建立连接,处理发送到指定端口的数据
ServerSocket server=new ServerSocket(8800);
获取客户端对象
Socket socket=server.accept();
数据流中读写信息
InputStream is=socket.getInputStream();
byte[] buf=new byte[1024];
int len=is.read(buf);
syso(new String(buf,0,len))
socket.shutdownInput();
关闭所有的数据流和Socket
is.close();
socket.close();
server.close()
序列化对象
User user=new User();//User是用户类
user.setLoginName("Tom");
user.setPwd("123456");
oos.writeObject(user);
通信双发不需要建立连接 ,通信双方完全平等
import java.io.IOException;
import java.net.*;
public class Client {
public static void main(String[] args) throws IOException, InterruptedException {
DatagramSocket datagramSocket = new DatagramSocket(new InetSocketAddress(InetAddress.getByName("localhost"),8888));
datagramSocket.connect(InetAddress.getByName("localhost"), 9999);
ReadThread readThread = new ReadThread(datagramSocket);
WriteThread writeThread = new WriteThread(datagramSocket);
readThread.start();
writeThread.start();
}
}
public class Client2 {
public static void main(String[] args) throws IOException, InterruptedException {
DatagramSocket datagramSocket = new DatagramSocket(new InetSocketAddress(InetAddress.getByName("localhost"),9999));
datagramSocket.connect(InetAddress.getByName("localhost"), 8888);
ReadThread readThread = new ReadThread(datagramSocket);
WriteThread writeThread = new WriteThread(datagramSocket);
readThread.start();
writeThread.start();
}
}
import java.nio.charset.StandardCharsets;
public class ReadThread extends Thread{
private DatagramSocket datagramSocket;
private byte[] bytes = new byte[1024];
private byte[] bytes1;
DatagramPacket datagramPacket = new DatagramPacket(this.bytes, 0,1024);
public ReadThread(DatagramSocket datagramSocket){
this.datagramSocket = datagramSocket;
}
@Override
public void run() {
super.run();
while (true){
try {
this.datagramSocket.receive(this.datagramPacket);
this.bytes1 = new String(this.bytes, 0, this.bytes.length).getBytes(StandardCharsets.UTF_8);
System.out.println(new String(this.bytes1, 0, this.bytes1.length));
Thread.sleep(2);
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}
}
import java.util.Scanner;
public class WriteThread extends Thread{
private DatagramSocket datagramSocket;
private String message = "";
private byte[] bytes = new byte[1024];
private Scanner scanner = new Scanner(System.in);
public WriteThread(DatagramSocket datagramSocket){
this.datagramSocket = datagramSocket;
}
@Override
public void run() {
super.run();
while (true){
synchronized (WriteThread.class){
System.out.print("输入:");
this.message = this.scanner.nextLine();
}
DatagramPacket datagramPacket = null;
try {
datagramPacket = new DatagramPacket(message.getBytes(StandardCharsets.UTF_8),0, message.length(), new InetSocketAddress(InetAddress.getByName("localhost"),datagramSocket.getPort()));
} catch (UnknownHostException e) {
e.printStackTrace();
}
try {
datagramSocket.send(datagramPacket);
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
Thread.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
Lambda表达式是 Java8 中最重要的新功能之一。使用 Lambda 表达式可以替代只有一个抽象函数的接口实现,告别匿名内部类,代码看起来更简洁易懂。 Lambda表达式同时还提升了对集合、框架的迭代、遍历、过滤数据的操作
任何有函数式接口的地方
只有一个抽象方法(Object类中的方法除外) 的接口是函数式接口
方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法,方法引用提供了一种引用而不执行方法的方式,如果抽象方法的实现恰好可以使用调用另外一个方法来实现,就有可能可以使用方法引用
作者:Djdj
链接:http://www.javaheidong.com/blog/article/112441/bf721bfadc8b2e206f32/
来源:java黑洞网
任何形式的转载都请注明出处,如有侵权 一经发现 必将追究其法律责任
昵称:
评论内容:(最多支持255个字符)
---无人问津也好,技不如人也罢,你都要试着安静下来,去做自己该做的事,而不是让内心的烦躁、焦虑,坏掉你本来就不多的热情和定力
Copyright © 2018-2021 java黑洞网 All Rights Reserved 版权所有,并保留所有权利。京ICP备18063182号-2
投诉与举报,广告合作请联系vgs_info@163.com或QQ3083709327
免责声明:网站文章均由用户上传,仅供读者学习交流使用,禁止用做商业用途。若文章涉及色情,反动,侵权等违法信息,请向我们举报,一经核实我们会立即删除!