java大数据

发表于 | 更新于 | 分类于 | 阅读次数：
java基本了解
1
2
3
4
5
6
7
jvm:java虚拟机,java跨平台的关键,实现将程序转换成操作系统可识别的指令
jre:java runtime environment,java运行环境,包含jvm
jdk:java development kit,java扩展包
java1.0-java15版本的发展及LTS版本,目前java8和11用的最多
java se:java 标准版,最基本的 ---->可认为做电脑上软件的
java ee:java 企业版 ------>可认为做网站的
java me:java 微型版,嵌入式开发,现在用的少,如安卓是基于me开发的------>可认为做手机软件的
视频学习流程
1
2
3
java基本数据类型--->面向对象,什么继承、封装、多态、构造方法、抽象类、接口、关键字--->常见的包,object,string,date,time,Arrays--->接口List(arraylist、linkedlist、vector）和Set（hashset、linkedhashset）--->collection和map(类似于字典,由键值构成,键不能相同)，

常用的工具:datax(拉数据),dolphinscheduler
基本运算
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
1.四舍五入,(int)为强制类型转换
	float a = 1.5f;
	int b = (int)(a+0.5) 
2.不会自动转换类型
	double d = 1.2 + 24 / 5; // 5.2
	可强制:double d = 1.2 + (double)24 / 5;
3.基本的逻辑判断形如if-else	
	a = 2;
	System.out.println(a==2?"通过":"失败");

4.除法规范
	整数相处,除数不能为0
	浮点数相除,除数可以为0
		NaN表示Not a Number 0/0.0
		Infinity表示无穷大 2/0.0
		-Infinity表示负无穷大 -2/0.0
5.三元运算符:b ? x : y

6.字符串变量命名,假如先定义了一个a="66",然后在重新赋值a="77",实际上66并没有被删除,只是无法获取到

7.空字符串不等于空值null

8.数组操作
	int[] a new int[5] //创建数组a,长度为5
	a.length //数组长度
	a[0] //获取指定索引的元素
	a[0] = 2
	a[1] = 2
	或者直接int[] b = new int[] {1,2,3,4,5};
	int[] b = {1,2,3,4,5};
9.逻辑控制:
	public class Hello{
	public static void main(String[] args) {
		int a = 20;
		int b = 10;
		int c = 30;
		if (a==20) System.out.println("正确");
		if (b==10) {
			System.out.println("进来了"+b);
		}
		if (c>85) {
			System.out.println("非常棒");
		}else if (c>60) {
			System.out.println("还行");
		}else if (c>30) {
			System.out.println("不太行");
		}else {
			System.out.println("垃圾");
		}
	}
}
10.switch case
public class Hello{
 	public static void main(String[] args)
    {
        int a = 10;
        switch(a)
        {
            case 10:
            System.out.println("10");
            break;
            case 2:
            System.out.println("2");
            break;
        }
    }
}
11.while 先判断条件在循环
public class Hello{
	public static void main(String[] args)
	{
		int a = 10;
		int sum = 0;
		while (a < 20) {
			sum+=a;
			a+=1;
		}
		System.out.println(sum);
	}
}
12.do while 先循环在判断条件    
public class Hello{
	public static void main(String[] args)
	{
		int a = 8;
		do {
			a+=1;
		}while(a >15);
		System.out.println(a);
	}
}
13.for循环
public class Hello{
	public static void main(String[] args)
	{
		int a = 8;
		for (int b=1;b<=a;b++)
		{
			System.out.println(b);
		}
	}
}
14.遍历列表
public class Hello{
	public static void main(String[] args)
	{
		int[] ns = {1,2,3,4,5,6};
		for (int a=0;a < ns.length;a++)
		{
			int b = ns[a];
			System.out.println(b);
		}
	}
15.排序
	冒泡排序
	import java.util.Arrays;
	public class Hello{
    public static void main(String[] args){
    int[] ns = {23,34,12,19,23,25};
    System.out.println(Arrays.toString(ns));
    for (int i = 0;i<ns.length-1;i++)
    {
    	for (int j = 0;j < ns.length-i-1;j++)
    	{
    	if (ns[j]>ns[j+1])
    		{
    		int tmp = ns[j+1];
    		ns[j+1] = ns[j];
    		ns[j] = tmp;
    		}
    	}
    }
    System.out.println(Arrays.toString(ns));
    }
	}
16.双层数组
//两层数组
import java.util.Arrays;
public class Hello{
	public static void main(String[] args)
	{
		int[][] ns = {
				{1,2,3},
				{3,4,3},
				{1,2,5},
	};
		System.out.println(Arrays.toString(ns[0]));
}
}

面向对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
class Person{
	public String name;
	public int a;
}
public class Hello{
	public static void main(String[] args)
	{
		Person person = new Person();
		person.name = "xiaoliang";
		person.a = 10;
		System.out.println(person.name);
				
	}
	
}

1.成员变量和局部变量
	定理在类中属性位置的称为成员变量,为所有成员共有.定位在方法下的属性称为局部变量
    
2.三大特性：继承、封装、多态
	封装：
    	1.代码复用性高
        2.整合起来，提供输出的接口，别人看不到具体的实现细节
        3.安全
3.private私有属性
private int a;
对象内的私有化后,无法提供外部获取途径是不合理的,因为可以通过内部方法调用来实现

4.		ArrayList<Student> list = new ArrayList<Student>(); //1.1创建一个可以存储多个同学名字的容器


抽象类没法直接new，抽象类下的抽象方法没有发括号、抽象类中不一定包含抽象方法、抽象类的子类必须重载所有的抽象方法
案例:
 public abstract class Animal {
    public abstract void eat();//抽象方法,内容不确定,没有发括号
    public void normalMethod(){}
}
public class Cat extends Animal {
    @Override
    public void eat(){
        System.out.println("Cat eat fish");
    }
}
public class DemoMain {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
    }
}

接口:定义上和类定义一致,可理解为是一个特殊的抽象类，但它不是类，是一个接口
接口最重要的体现：解决多继承的弊端。将多继承这种机制在java中通过多实现完成了。
接口:比抽象类更抽象的一个数据类型,接口类里只描述方法,具体实现通过子类.接口定义,类去实现(类似于继承不同的是一个是extends一个是implement)
interface Fu1
{
	void show1();
}
interface Fu2
{
	void show2();
}
class Zi implements Fu1,Fu2// 多实现。同时实现多个接口。
{
	public void show1(){}
	public void show2(){}
}
接口案例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
interface USB {
	void open();// 开启功能

	void close();// 关闭功能
}
class Mouse implements USB {
	public void open() {
		System.out.println("鼠标开启");
	}

	public void close() {
		System.out.println("鼠标关闭");
	}
}
class KeyBoard implements USB {
	public void open() {
		System.out.println("键盘开启");
	}

	public void close() {
		System.out.println("键盘关闭");
	}
}
class NoteBook {
	// 笔记本开启运行功能
	public void run() {
		System.out.println("笔记本运行");
	}

	// 笔记本使用usb设备，这时当笔记本对象调用这个功能时，必须给其传递一个符合USB规则的USB设备
	public void useUSB(USB usb) {
		// 判断是否有USB设备
		if (usb != null) {
			usb.open();
			usb.close();
		}
	}

	public void shutDown() {
		System.out.println("笔记本关闭");
	}
}

public class Test {
	public static void main(String[] args) {
		// 创建笔记本实体对象
		NoteBook nb = new NoteBook();
// 笔记本开启
		nb.run();

		// 创建鼠标实体对象
		Mouse m = new Mouse();
		// 笔记本使用鼠标
		nb.useUSB(m);

// 创建键盘实体对象
		KeyBoard kb = new KeyBoard();
		// 笔记本使用键盘
		nb.useUSB(kb);

		// 笔记本关闭
		nb.shutDown();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
修饰符:final 固定
	static 静态
static 静态修饰符,如在类中修饰属性,则实例化多个对象时是共享这个值
private、protected、default、public
要想仅能在本类中访问使用private修饰；
要想本包中的类都可以访问不加修饰符即可；
要想本包中的类与其他包中的子类可以访问使用protected修饰
要想所有包中的所有类都可以访问使用public修饰。

常用来修饰类、方法、变量的修饰符如下：
public 权限修饰符，公共访问, 类,方法,成员变量
protected 权限修饰符，受保护访问, 方法,成员变量
默认什么也不写 也是一种权限修饰符，默认访问, 类,方法,成员变量
private 权限修饰符，私有访问, 方法,成员变量
static 静态修饰符  方法,成员变量
final 最终修饰符   类,方法,成员变量,局部变量
abstract 抽象修饰符  类 ,方法

我们编写程序时，权限修饰符一般放于所有修饰符之前，不同的权限修饰符不能同时使用；
同时，abstract与private不能同时使用；
同时，abstract与static不能同时使用；
同时，abstract与final不能同时使用。

☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
继承:一个子类只能有一个父类,但是可以有多层结构c继承b,b继承a.自己有的优先调用自己的,没有才去父类调

//接口和抽象类:抽象类是对类的抽象,即单一的类无法描述所有情况的时候,而接口是一种扩展的功能,不是所有都使用
//一个类智能继承一个父类,但是可以继承多个接口implement a,b,c  extends a


多态的体现:父类引用变量可以指向子类对象,相同的事物在不同的类有不同的含义(如既是老师也是学生)====变量调用的 是父类的变量,方法调用的是子类重载的方法
成员变量，静态方法看左边；非静态方法：编译看左边，运行看右边。”意思是：当父类变量引用子类对象时,Fu f = new Zi();在这个引用变量f指向的对象中，他的成员变量和静态方法与父类是一致的，他的非静态方法，在编译时是与父类一致的，运行时却与子类一致（发生了复写）

继承时候,构造方法父类的会先执行,默认含有一个隐式的super()



关键词解释:
	final:写在类前,表示该类不能被继承.写在方法前,表示该方法不能被重载.写在变量前表示该变量不能被二次赋值,否则会报错.
	
	static:静态修饰符,放在成员变量前,表示该变量是静态变量,public static int num = 2,可通过类名+变量获取,同时静态变量是所有实例化的对象共享的,一个改变则都跟着改变.  放在方法前表示该方法是静态方法,静态方法中只能访问静态变量或静态方法,同时不能使用super和this关键字
	public class demo3 {
    public static  void main(String [] args)
    {
        System.out.println(person.get_name());  //调用静态方法
    }
}

class person{
    public static String name = "xixom";
    public static String get_name(){
        return name;
    }
}
注意:接口中的每个成员变量都默认使用public static final修饰。
所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名访问。Inter.COUNT

匿名对象:实例化的对象没有赋值给变量 如new person()

面向对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
scala是完全面向对象的,为了实现static,通过伴生对象实现

抽象类:里面既可以包含抽象属性、抽象方法、非抽象属性和非抽象方法,针对私有化的属性,可以通过伴生类去调用,在通过伴生类来进行调用.父类中的var属性在子类中可以直接修改,不需要override,会报错,子类继承的时候针对抽象方法可以不写override,针对非抽象方法必须写override

特质trait也是抽象类,类似于java的接口,可以看成是方法的补充,区别是不能初始化属性,mixin混入,即可以wit很多特质

类型判断和类型转换isinstanceof和asinstanceof
	
枚举类对象和应用类
object WorkDay extends Enumeration{
val Monday = value(1,"MONDAY")
}

应用类 
object test extends APP{}===>省略main方法

自定义类型
type Mystring = String 则Mystring可以当做string来使用

集合

1
2
3
4
5
6
7
8
分为三大类seq、set、和map
创建数组
new Array[Int](10)==>简化Array(1,2,3,4,5...)==>实际上调用的apply方法,apply可省略

不可变数组追加数据 array1.:+(2)==>往后追加array1 +: 2
				array1.+:(3)===>往前追加 2 +:
数组、可变数组的增删改查
互相转换 arrai.toBuffer,arra2.toArray

接口API

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
api:applicantion promming interfaces 应用程序接口
类说明:
##########################object#######################
1.clone:复制产生的是一个新对象,属性跟原本一样,只能在子类中用
2.getclass
3.finalize
4.equals:重构问题※※※※※
5.tostring:重构问题※※※※
ogject是一切类的父类
jdk中含有包的说明
##########################string#######################


#############################map##################

Map<String, String> map = new HashMap<String,String>();

public class MapDemo {
	public static void main(String[] args) {
		//创建Map对象
		Map<String, String> map = new HashMap<String,String>();
		//给map中添加元素
		map.put("邓超", "孙俪");
		map.put("李晨", "范冰冰");
map.put("刘德华", "柳岩");
		//获取Map中的所有key
		Set<String> keySet = map.keySet();
		//遍历存放所有key的Set集合
		Iterator<String> it =keySet.iterator();
		while(it.hasNext()){
			//得到每一个key
			String key = it.next();
			//通过key获取对应的value
			String value = map.get(key);
			System.out.println(key+"="+value);
		}
	}
}



######排序和打乱
collections.sort() 和collections.shuffle()
集合框架
1
2
3
4
5
6
7
8
9
10
1.集合框架(类似Python的容器)分成collection(集合)===>元素的集合,和map(图)===>键值对的形式.
2.集合框架下分成list、set和queue
3.list下分成arraylist（数组），linkedlist（链表）、vector(抛弃了,被Arraylist和itertool替代了).(list集合下根据数据结构的不同可分成多部分,如栈、队列、数组、链表，其中数组取元素快，增删麻烦。链表增删数据简单，取数据慢---需要一个一个找，手拉手)
4.list下最常用的还是Arraylist
5.声明  List<String> = new Arraylist<String>;
6.因为List中会允许存在重复数据,这时候需要去重,使用的是Set
7.set内分成hashset和linkedhashset
8.hashset去重的原则是hashcode和equals,如果输入的是自定义的对象,则需要重写hashcode和equals方法
9.哈希表:又名哈希数组,底层使用的是数组存放对象,然后会根据对象的特有数据和特定的算法,计算出对象在数组中未位置,然后把对象存放在数据中.
10.linkedhashset是hashset下的一个结构,可实现去重及排序,使用的是哈希表和链表实现的

进程、线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
进程是程序执行的最小单位,线程是资源调度的最小单位
每个核同时只能执行一个线程,window默认只使用一个核,只是切换的速度超过人眼反应,因而可以同时开很多个程序.且速度和核数并非成线性的,开四个核实际提升可能只有2倍左右.

线程实现的两种方式一个是继承thread ,另一个是使用接口runnable接口.更多的是使用第二个,因为第一个存在单继承的局限性.
    线程池:减少线程的创建和销毁的资源消耗,有放回的获取线程

线程安全:针对全局变量如果多个线程只有读的操作,则认为是线程安全的.如果多某个变量进行写操作,需要多个线程同步,否则就是不安全的.
    
解决线程不安全问题: 使线程同步Synchronized
	实现方式:
	1.同步代码块
		在可能会出现线程不安全的代码前加上Synchronized(锁对象){代码内容}即可
	2.同步方法
		将可能会出现问题的代码写成方法,public Synchronized void method(){内容}
	3.同步静态方法: 在方法前加上static 。public static Synchronized void method(){内容}

死锁:独木桥案例,抢资源谁也不让谁
	通常是一个线程锁定了一个资源A，而又想去锁定资源B；在另一个线程中，锁定了资源B，而又想去锁定资源A以完成自身的操作，两个线程都想得到对方的资源，而不愿释放自己的资源，造成两个线程都在等待
	1.有多把锁
	2.有多个线程
	3.同步代码快嵌套
	通俗:两个线程,一个线程拿到了锁A,想拿锁B.但是宁外一个线程拿到了锁B,想要拿锁A.对方不释放则都拿不到,就这样僵持,造成了
异常
1
2
3
4
5
6
1.几个关键词:throw、throws、finally、try、catch
2.通常try{} catch（）{}；类似python try except
3.throws的作用通常是修饰方法的，表面了该方法可能会抛出的异常，需要自己解决
4.finally不管是try还是catch后,都会执行,除非遇到system.exit(),通常是用来释放资源,关闭连接的
5.执行顺序,首先执行try,如果有异常则执行catch,若没有catch,则先执行finally,然后再去找合适的catch
6. throw 手动抛出异常 throw new IllegalArgumentException("w");

其他

1
2
3
构造方法的执行流程:
	1. 在栈中执行main方法,在堆中创建对象,并对属性值进行默认值赋予.栈中存放着对象的地址.
	2. 使用构造方法,会将传入的值赋给对象的参数