Java基础

Java基础

前篇

1. JRE、JDK

1. Java中内存分配

虚拟机自动调用main方法，进入栈中运行

变量与方法

1. 面试题

1.1 成员变量与局部变量的区别有哪些

a. 概念

b. 作用域

c. 存储位置

d. 生命周期

e. 初始值

f. 使用原则：

1.2 在Java中定义一个不做事且没有参数的构造方法的作用

java在执行子类的构造方法之前，若没有指定super(…)，则会默认调用父类的无参构造方法，若此时父类中只有有参构造方法，则编译时会发生错误。

1.3 在调用子类构造方法之前会先调用父类没有参数的构造方法，其目的是？

帮助子类做初始化工作

1.4 一个类的构造方法的作用是什么？若一个类没有声明构造方法，改程序能正确执行吗？为什么？

new一个对象的时候需要调用该类的构造方法，系统默认会创造一个不带参数的构造方法
官方：
主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。

1.5 构造方法有哪些特性？

1.6 静态变量和实例变量区别

静态变量： 静态变量由于不属于任何实例对象，属于类的，所以在内存中只会有一份，它当且仅当在类初次加载时会被初始化，JVM只为静态变量分配一次内存空间。

实例变量： 每次创建对象，都会为每个对象分配成员变量内存空间，实例变量是属于实例对象的，在创建对象的时候被初始化，在内存中，创建几次对象，就有几份成员变量。

1.7 静态方法和实例方法有何不同？

1.8在一个静态方法内调用一个非静态成员为什么是非法的？

1.9 什么是方法的返回值？返回值的作用是什么？

1.10值传递和引用传递有什么区别

1.11 对象相等判断之==和equals的区别？

1.12 hashCode 与 equals

2. 构造方法

2.1. 概述

若想都用，则两个构造方法都手动创建。直接给对象赋值了，姓名和年龄

2.2. 注意事项：

2.3. 方法重载

2.3.1. 概述

2.3.2. 好处

2.3.3. 面试题之方法重写与重载

3.1 构造器（constructor）是否可被重写（override）？
构造器不能被继承，因此不能被重写，但可以被重载。

3.2 重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分？

面向过程和面向对象(封装、继承、多态)

1. 概念

2.封装

2.1 解释

2.2 面试

3. 继承

《就近原则》

重要：子类中所有的构造方法默认都会先调用父类的无参构造方法！！！

super关键字

3.1. 继承中访问构造方法和成员变量的特点

3.2. 继承中成员方法访问特点：

3.3. super内存图

3.4. 方法重写

3.5.java中继承的注意事项

3.6. 案例

package com.weichen.test;
public class Test_fu_zi {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dog dog=new Dog("狗",22);
		dog.method();
		System.out.println(dog.getName()+dog.getAge());
		
		Cat cat=new Cat("猫",22);
		cat.method();
		System.out.println(cat.getName()+cat.getAge());
	}
}
class Animal{
	private String name;
	private int age;
	public Animal() {	
	}
	public Animal(String name,int age) {
		this.name=name;
		this.age=age;
	}
	public void setName(String name) {
		this.name=name;
	}
	public void setAge(int age) {
		this.age=age;
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
}
class Dog extends Animal{
	public Dog() {
		
	}
	public Dog(String name,int age) {
		super(name, age);
	}
	public void method() {
		System.out.println("我是狗，我可以看门");
	}
	
}
class Cat extends Animal{
	public Cat() {
		
	}
	public Cat(String name,int age) {
		super(name, age);
	}
	public void method() {
		System.out.println("我是猫，我可以抓老鼠");
	}
	
}

3.7. 面试之继承

3.8. 面试之super关键字的使用

4. 多态

4.1 概述

4.2 多态转型内存图解

数组：

1. 基本使用：

package com.weichen.test;

import java.util.Arrays;

public class Array_usually {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//声明一个数组并分配空间：必须指定数组大小
		int[] arr1=new int[2];
		int[] arr2= {1,2,3,4};
		int[] arr3=new int[] {1,2,3,4};
		
		
		//数组的遍历方式1：
		for(int score:arr1) {
			System.out.println(score);
		}
		
		//数组的遍历方式2
		for(int i=0;i<arr2.length;i++) {
			System.out.println(arr2[i]);
		}
		
		
		//Arrays数组工具类的使用
		//1. 比较两个数组是否相等
		System.out.println("比较两个数组是否相等:"+Arrays.equals(arr2, arr3));  
		
		
		//2. 对数组的元素进行升序排列
		Arrays.sort(arr3); 
		System.out.println("对数组的元素进行升序排列:");
		for(int score:arr3) {
			System.out.println(score);
		}
		
		//3.将一个数组转换成一个字符串
		System.out.println("将一个数组转换成一个字符串"+Arrays.toString(arr2));
		
		//4.把数组array所有元素都赋值为val
		System.out.println("把数组array所有元素都赋值为val");
		Arrays.fill(arr1, 7);
		for(int score:arr1) {
			System.out.println(score);
		}
		
		//5.把数组复制成一个长度为length的新数组，返回类型与复制的数组一致
		int[] new_Array =Arrays.copyOf(arr1, 5);
		System.out.println("把数组复制成一个长度为length的新数组，返回类型与复制的数组一致");
		for(int score:new_Array) {
			System.out.println(score);
		}
		
		
		//6.查询元素值val在数组array中的下标(要求数组中元素已经按照升序排列)
		System.out.println("查询元素值7在数组arr1中的下标(要求数组中元素已经按照升序排列)");
		System.out.println(Arrays.binarySearch(arr1, 7));
		
	}

}

2、二维数组

3. LeetCode

import java.util.Arrays;
public class leetcode_01 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] heights= {1,1,4,2,1,3};
		int count=heightChecker(heights);
		System.out.println(count);

	}

	    public static int heightChecker(int[] heights) {
	    	int[] new_heights=heights.clone();
	    	int count=0;
	    	Arrays.sort(new_heights);

	            for(int i=0;i<heights.length;i++){
	                if(new_heights[i]==heights[i]){
	                    count++;
	                }
	            }
	            return count;
	    }
}

package com.weichen.test;
public class Leetcode_arr02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr= {1,1,1,1,1};
		Solution solution=new Solution();
		int result=solution.numOfSubarrays(arr,1,0);
		System.out.println(result);
	}
}
class Solution {
    public int numOfSubarrays(int[] arr, int k, int threshold) {
    	int count=0;    //记录满足条件的数组个数	 
    	
    	//找出子数组
    	int[] sub_arr=new int[k]; 	
    	for(int i=0;i<arr.length-k+1;i++) {  		   		
    		int temp=i;
    		for(int j=0;j<k;j++) {
    			sub_arr[j]=arr[temp++];
    		}
    		if(avg(sub_arr)>=threshold) {
    		    count++;
        	}
    	}		
    	return count;
    }

    //求平均值
    public int avg(int[] arr) {
    	int sum=0;
    	for(int i=0;i<arr.length;i++) {
    		sum+=arr[i];
    	} 	
		return sum/arr.length; 	
    }
}

package com.weichen.test;

import java.util.HashSet;
import java.util.Set;

public class Leetcode_04 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Solution_1 solution=new Solution_1();
		int[] nums= {2,2,3,4,5};
		int result=solution.findRepeatNumber(nums);
		System.out.println(result);
	}

}
class Solution_1 {
    public int findRepeatNumber(int[] nums) {
    	Set<Integer> set=new HashSet<Integer>();
    	int repeat=-1;
    	for(int num:nums) {
    		if(!set.add(num)) {
    			repeat=num;
    			break;
    		}
    	}  	
    	return repeat;
    }
}

4、案例

数组反转

public class test_flower {
	public static void main(String[] args) {
		int[] arr=new int[] {19,28,37,46,50,60};
		for(int start=0,end=arr.length-1;start<end;start++,end--) {
			int temp=arr[start];
			arr[start]=arr[end];
			arr[end]=temp;
		}
		for(int arrs:arr) {
			System.out.println(arrs);
		}
	}
}

常用API之String类型

1. 概述

2. String常见构造方法（构造方法用来创建对象）

package com.weichen.test;
public class Test_String {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 * 字符串特点：
		 * 1. java程序中，所有的双引号字符串，都是String这个类的对象，利用对象可以直接调用String的对象
		 * 2. 字符串是常量，值在创建之后不能被更改若要更改，只是又指向了另外一个字符串对象而已
		 */
		//创建字符串对象的四种方式：
		String string="weichen";
		string.length();
		
		//public String()
		String s1=new String();
		System.out.println(s1);
		
		//public String(char[] chs)
		char[] cs= {'a','b','c'};
		String string2=new String(cs);
		System.out.println(string2);   //把一个个字符串成一个字符串    abc
		
		//public String(String original)
		String string3=new String("123");
		System.out.println(string3);
	}
}

3. 以上构造方法创建字符串对象的区别对比

4. 字符串的比较（==，equals）

5.遍历字符串

6.统计字符次数

package com.weichen.test;
import java.util.Scanner;
//判断一个字符串中有几个大写字母，几个小写字母，几个数字
//先将一个字符串转换成一个字符数组，然后对数组中的每一个字符进行判断
//判断字符是否为大写、小写、数字的方法
public class Test02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入一个字符串");
		String string=scanner.nextLine();	
		int count_A=0,count_a=0,count_1=0;
		char[] a=string.toCharArray();
		
		for(int i=0;i<a.length;i++) {
			if(a[i]>='A'&&a[i]<='Z')   //判断一个字符是否是大写字母
			{
				count_A++;
			}
			if(a[i]>='a'&&a[i]<='z')   //判断一个字符是否是小写字母
			{
				count_a++;
			}
			if(a[i]>='0'&&a[i]<='9')   //判断一个字符是否是数字
			{
				count_1++;
			}
		}
		System.out.println("A"+count_A);
		System.out.println("a"+count_a);
		System.out.println("1"+count_1);
	}

}

7. 手机号屏蔽

8. 敏感词替换

9.切割字符串

10.拼接字符串(用StringBuilder.append()方法)

package com.weichen.test;
import java.util.Scanner;
//截取字符串方法
public class Test02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr= {1,2,3};
		String resultString=int_String(arr);
		System.out.println(resultString);
		
	}
	
	public static String int_String(int[] arr) {
		StringBuilder sBuilder=new StringBuilder("[");
		for(int i=0;i<arr.length;i++){
			if(i==arr.length-1) {
				sBuilder.append(arr[i]).append("]");
			}else {
				sBuilder.append(arr[i]).append(",");
			}
		}
		return sBuilder.toString();
	}
}
		
		

11. 小结

12.面试

12.1字符型常量和字符串常量的区别

12.2 什么是字符串常量池？

12.3 String 是最基本的数据类型吗

12.4 String有哪些特性

12.5String为什么是不可变的吗？

通过反射…不懂

12.6 是否可以继承 String 类

String 类是 final 类，不可以被继承。

12.7 String str="i"与 String str=new String(“i”)一样吗？

12.8 String s = new String(“xyz”);创建了几个字符串对象

12.9 如何将字符串反转？

12.10 数组有没有 length()方法？String 有没有 length()方法

数组没有 length()方法 ，有 length 的属性。String 有 length()方法。JavaScript中，获得字符串的长度是通过 length 属性得到的，这一点容易和 Java 混淆。

12.11 String 类的常用方法都有那些？

12.12 在使用 HashMap 的时候，用 String 做 key 有什么好处？（需要回顾）

12.13. String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的

运算符：

1. 常用运算符

2. 面试

2.1数据交换

2.2 &和&&的区别

修饰符

1. 权限修饰符【访问】(public、protected、默认、private)

1.1 理解

1.2 面试题

2. final修饰符【更改】

2.1 final修饰成员变量、成员方法、类

2.2 final修饰基本类型和引用类型变量

2.3 final 有什么用？

2.4 final finally finalize区别（遗留）

3.static修饰符

3.1 用static修饰成员变量（2个知识点）

3.2 static访问特点

3.3 面试之static存在的主要意义

3.4 面试之staticstatic的独特之处

3.5 面试之static应用场景

关键字

1. private关键字

2. this关键字：

2.1 简介

2.2 内存原理

2.3 面试之this关键字的用法

2.4 this和super的区别

接口：

1. 接口描述：

2.接口特点

3. 接口的成员特点

4.示例

5. 类和接口的关系

6. 抽象类和接口的区别

7. 案例

8. 用接口作为形参或者返回值类型为接口

抽象类：

1. 概述

2. 特点：

3. 抽象类和接口的区别

内部类

1. 概述

2. 内部类定义格式

3. 内部类的访问特点：

4. 内部类分类

4.1 成员内部类

4.2 局部内部类

4.3 匿名内部类

4.4 匿名内部类在开发中的使用

package com.weichen.test;
public class Inner_class {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		JumppingOperator jumppingOperator=new JumppingOperator();
		
		Jummpping jummpping=new Jummpping() {
			
			@Override
			public void jump() {
				// TODO Auto-generated method stub
				System.out.println("tiaogao");
			}
		};
		jumppingOperator.method(jummpping);	
		
		//或者
		jumppingOperator.method(new Jummpping() {
			
			@Override
			public void jump() {
				// TODO Auto-generated method stub
				System.out.println("tiaogao");
			}
		});
	}
}
interface Jummpping{
	void jump();
}
class JumppingOperator{
	public void method(Jummpping j) {
		j.jump();
	}
}

4.5 静态内部类

5. 内部类面试题

5.1 什么是内部类？

在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内部类本身就是类的一个属性，与其他属性定义方式一致。

5.2 内部类的分类

内部类可以分为四种：成员内部类、局部内部类、匿名内部类和静态内部类。

1. 静态内部类：定义在类内部的静态类
   创建方式：new 外部类.静态内部类()
2. 成员内部类：定义在类内部，成员位置上的非静态类
   创建方式：外部类实例.new 内部类()
3. 局部内部类：定义在方法中的内部类
   创建方式：在对应方法内，new 内部类()
4. 匿名内部类：匿名内部类就是没有名字的内部类

5.3 内部类的优点

5.4 内部类的应用场景

5.5 局部内部类和匿名内部类访问局部变量的时候，为什么变量必须要加上final？

集合类

集合类之ArrayList

1. 概述

2. 方法

3. 示例

4. 常用方法

常用API

1. Random

1.1 作用和基本步骤

2. Math

2.1 Math概述

2.2 常用方法

2.3 易出错

Math.round(11.5)的返回值是 12，Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加 0.5 然后进行下取整。

3.System类

3.1 概述&常用方法

4. Object类

4.1 概述和常用方法

4.2 面试题之== 和 equals 的区别是什么：

4.3 hashCode 与 equals (重要)（遗留）

1. HashSet如何检查重复：
   HashSet底层数据结构是hash表和数组
   IDK通过hashcode()方法计算每个对象的hash值，返回的是一个int类型的整数，用该hash值确定对象在hash表中的索引位置。在Object()类的默认hashcode()方法中，每个对象的hash值都是不同的。

5. Arrays类

5.1 Arrays类的概述和常用方法

6. 基本类型包装类

6.1 基本类型包装类概述

6.2 Integer类的概述和使用

6.3 案例

6.4 自动装箱和拆箱

7. 日期类

7.1 常用方法和构造方法

7.2 案例

package com.weichen.test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Datedemo {

	public static void main(String[] args) throws ParseException {
		// TODO Auto-generated method stub
		DateUtils dateUtils=new DateUtils();
		String string="2018-09-08 20:20:20";
		dateUtils.str_to_date(string,"yyyy-MM-dd HH:mm:ss");
		
		Date date=new Date();
		dateUtils.date_to_str(date,"yyyy年MM月dd日 HH:mm:ss");		
	}
}
class DateUtils{
	public void str_to_date(String str,String format) throws ParseException {
		//把字符串解析为指定格式的日期    注意此处传入的字符串格式要和构造方法中的参数一致
		Date date=new Date();
		SimpleDateFormat simpleDateFormat=new SimpleDateFormat(format);
		date=simpleDateFormat.parse(str);
		System.out.println(date);
	}
	public void date_to_str(Date date,String format) {
		//把指定格式的日期转换成指定格式的字符串    传入一个时间和想要的字符串的格式
		SimpleDateFormat simpleDateFormat=new SimpleDateFormat(format);
		String string=simpleDateFormat.format(date);
		System.out.println(string);
	}
	
}

异常

1. 异常概述

2. JVM的默认处理方案

3. 异常处理

4. 编译时异常和运行时异常的区别

5. 异常处理之throws

6. 自定义异常

7. throws和throw的区别

集合

1. Collection

1.1 集合类体系结构

1.2 Collection集合常用方法

1.3 Collection集合的遍历

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Num1 {
	public static void main(String[] args) {
		Collection<String> collection=new ArrayList<String>();   
		collection.add("hello");
		collection.add("world");
		
		Iterator<String> iterator=collection.iterator();
		while(iterator.hasNext()) {
			String string=iterator.next();
			System.out.println(string);
		}
	}
}

1.4集合的使用步骤

2. List

2.1 List集合的概述和特点

package com.weichen.test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> list=new ArrayList<String>();
		list.add("hello");
		list.add("world");
		list.add("java");
		list.add("hello");
		
		Iterator<String> iterator=list.iterator();
		while(iterator.hasNext()) {
			String string=iterator.next();
			System.out.println(string);
		}
	}
}

2.2 List集合特有方法（Collection没有，ArrayList有）

2.3 并发修改异常

2.4 ListIterator(可用迭代器添加元素，并且不会出现异常)

2.5 增强for循环

2.6 用三种方式遍历List集合

2.7 数据结构

2.8 List集合子类特点(ArrayList、LinkedList)

3. Set(不包含重复元素)

3.1 Set集合的概述和方法

3.2 hash值

3.3 HashSet(底层数据结构是哈希表，所以对象要重写hashcode()和equals()方法来保证元素的唯一性)

3.4 LinkedHashSet类

3.5 TreeSet集合具体类

3.6 自然排序Comparable的使用（创建TreeSet的带参构造方法）

3.7 比较器排序Comparator的使用(创建TreeSet的带参构造方法)

3.8 案例：

package com.weichen.test;
import java.util.Comparator;
import java.util.TreeSet;

//LinkedList 底层实现原理是链表   所以增删比较容易，查找不是很方便
public class Num1 {
	public static void main(String[] args) {
		TreeSet<Student11> treeSet=new TreeSet<Student11>(new Comparator<Student11>() {   //内部类的知识，创建接口的具体实现类，利用多态，重写方法
			@Override 
			public int compare(Student11 o1, Student11 o2) {
				// TODO Auto-generated method stub
				int num=(o2.getGrade_shuxue()+o2.getGrade_yuwen())-(o1.getGrade_shuxue()+o1.getGrade_yuwen());  //总分降序	
				int num2=num==0?o1.getGrade_shuxue()-o2.getGrade_shuxue():num;    //数学分降序
				int num3=num2==0?o1.getName().compareTo(o2.getName()):num2;       //姓名自然升序
				return num3;

			}
		});	
		treeSet.add(new Student11("zhangsan",11,22));
		treeSet.add(new Student11("lisi",22,33));
		treeSet.add(new Student11("wangwu",2,3));
		treeSet.add(new Student11("zhangsan",11,22));
		treeSet.add(new Student11("aerwer",2,3));
		treeSet.add(new Student11("ertert",3,2));
		for(Student11 student11:treeSet) {
			System.out.println(student11);
		}
		
		
}
}
class Student11{
	
	public Student11() {
		super();
	}
	public Student11(String name, int grade_yuwen, int grade_shuxue) {
		super();
		this.name = name;
		this.grade_yuwen = grade_yuwen;
		this.grade_shuxue = grade_shuxue;
	}
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getGrade_yuwen() {
		return grade_yuwen;
	}
	public void setGrade_yuwen(int grade_yuwen) {
		this.grade_yuwen = grade_yuwen;
	}
	public int getGrade_shuxue() {
		return grade_shuxue;
	}
	public void setGrade_shuxue(int grade_shuxue) {
		this.grade_shuxue = grade_shuxue;
	}
	private int grade_yuwen;
	private int grade_shuxue;
	@Override
	public String toString() {
		return "Student11 [name=" + name + ", grade_yuwen=" + grade_yuwen + ", grade_shuxue=" + grade_shuxue + "]";
	}		
}

3.9 案例之：不重复的随机数

import java.util.HashSet;
import java.util.Random;
public class Random_set {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	HashSet<Integer>  hashSet=new HashSet<Integer>();
//	while(hashSet.size()<10) {
//		Integer i=(int) Math.ceil(Math.random()*20);
//		hashSet.add(i);
//	}
	Random random=new Random();
	while(hashSet.size()<10) {
		int number=random.nextInt(20)+1;
		hashSet.add(number);
	}
	System.out.println(hashSet);
	}
}

4. 泛型

4.1 泛型概述

5. Map

5.1 概述和使用

5.2 Map的基本功能

碎碎念。
当利用hashset保证插入元素值唯一时
hashset的底层数据结构是hash表和链表
若想保证元素插入唯一，就首先要比较两个元素是否相等。若插入的是一个自定义的类，此时若要比较两个对象是否相等，需要比较这两个对象里面的内容，需要重写equals()方法，因为不重写的话，引用类型默认比较的是地址值。利用hashcode()函数计算出每个对象的hash值，若两个对象的hash值不同，则说明两个对象一定不一样，但是原始的hashcode（）函数出来的hash值，会使每个对象的hash值都不一样，所以在此要重写，若两个对象的hash值相同，再用equals(）比较内容，若hash值不同，则说明存储单元不同，此时就不用再比较内容了。
hash值相同但内容不同
hash值不同但是内容相同

5.3 案例1

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class Random_set {

	public static void main(String[] args) {
		HashMap<String, ArrayList> hashMap=new HashMap<String, ArrayList>();  //要求用hashmap集合存储元素  先定义一个hashmap对象
		ArrayList<String> list1=new ArrayList<String>();    //hashmap里面的每一个值都是一个ArrayList类型的，所以首先要创建多个ArrayList
		list1.add("qqq");
		list1.add("www");
		
		ArrayList<String> list2=new ArrayList<String>();
		list2.add("www");
		list2.add("rrr");
		
		ArrayList<String> list3=new ArrayList<String>();
		list3.add("rrr");
		
		hashMap.put("111", list1);
		hashMap.put("222", list2);
		hashMap.put("333", list3);
		
		Set<String> set=hashMap.keySet();
		for(String string:set) {   //先遍历键
			ArrayList<String> list=hashMap.get(string);      //再遍历值
			for(String valString:list) {
				System.out.println("键："+string+"---值："+valString);
			}
		}
	}		
}	

5.4 案例2

package com.weichen.test;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
//键盘输入一个字符串，返回各个以及个数
/*
 * 利用hashmap中键不同的特性存储每个字母
 * 默认值为null
 * map.add()  当键值相同时，重新赋值即可
 * 
 * */
public class Random_set {

	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入一个字符串");
		String string=scanner.nextLine();
		Count count = new Count();
		count.number(string);
	}		
}	
	

class Count{
	public void number(String str) {
	//TreeMap<Character,Integer> map=new TreeMap<Character, Integer>(); (对键值进行了排序)
		HashMap<Character,Integer> map=new HashMap<Character, Integer>();
		char[] ch=str.toCharArray();
		for(int i=0;i<ch.length;i++) {
			Integer value=map.get(ch[i]);
			if(value==null) {
				map.put(ch[i], 1);
			}else {
				map.put(ch[i], value+1);
			}
		}
		
		StringBuilder stringBuilder=new StringBuilder();
		Set<Character> key=map.keySet();
		for(Character character:key) {
			Integer integer=map.get(character);
			stringBuilder.append(character).append("(").append(integer).append(")");
			//System.out.print(character+"("+integer+")");
		}
		String string=stringBuilder.toString();
		System.out.println(string);
	}
}

6. Collections

6.1 概述和使用

6.2 案例

package com.weichen.practice;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CollectionsDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<Student> arrayList=new ArrayList<Student>();		
		Student s1=new Student("weichen",11);
		Student s2=new Student("zeichen",11);
		Student s3=new Student("aeichen",33);
		
		arrayList.add(s1);
		arrayList.add(s2);
		arrayList.add(s3);
		
		Collections.sort(arrayList,new Comparator<Student>() {
				public int compare(Student o1,Student o2) {
					//年龄从小到大
					int num=o1.getAge()-o2.getAge();
					int num1=num==0?o1.getNameString().compareTo(o2.getNameString()):num;
					return num1;
				}	
		});	
		for(Student student:arrayList) {
			System.out.println(student.getNameString()+student.getAge());
		}	
	}
	
}

6.3 斗地主升级版

package com.weichen.practice;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeSet;
public class PlayGame_up {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建HashMap
		HashMap<Integer, String> hashMaps=new HashMap<Integer, String>();
		// 存储编号
		ArrayList<Integer> arrayList=new ArrayList<Integer>();
		
	
		//存储牌
		String[] flower= {"♦","♣","♥","♠"};
		String[] number= {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
	
		//将花色和数字进行拼接
		int index=0;
		for(String numbers:number) {
			for(String flowers:flower) {
				hashMaps.put(index,flowers+numbers);
				arrayList.add(index);
				index++;		
			}
		}
		hashMaps.put(index, "大王");
		arrayList.add(index);
		index++;
		hashMaps.put(index, "小王");
		arrayList.add(index);
		
		
		//洗牌
		Collections.shuffle(arrayList);
		
	
		//发牌   给每个人发牌   三个玩家的容器
		TreeSet<Integer> player1=new TreeSet<Integer>();
		TreeSet<Integer> player2=new TreeSet<Integer>();
		TreeSet<Integer> player3=new TreeSet<Integer>();
		TreeSet<Integer> dpplayer=new TreeSet<Integer>();
		
				
		//向每个人的容器里面加牌
		for(int i=0;i<arrayList.size();i++) {
			int x=arrayList.get(i);
			if(i>=arrayList.size()-3) {
				dpplayer.add(arrayList.get(i));
			}else if(i%3==0) {
				player1.add(arrayList.get(i));
			}else if(i%3==1) {
				player2.add(arrayList.get(i));
			}else if(i%3==2){
				player3.add(arrayList.get(i));
			}
					
		}
		lookpocker("qqq",player1, hashMaps);
		lookpocker("www",player2, hashMaps);
		lookpocker("eee",dpplayer, hashMaps);
		lookpocker("底牌",player1, hashMaps);
		
				
	}
	
	//遍历牌，发的是编号，根据Arraylist中取的编号对应到hashmap中找元素值
	public static void lookpocker(String nameString,TreeSet<Integer> ts,HashMap<Integer, String> hm) {
		System.out.println(nameString+"的牌是：");
		for(Integer in:ts) {
			String pokerString=hm.get(in);
			System.out.print(pokerString+" ");
			
		}
		System.out.println();
	}
}

6.4 斗地主

package com.weichen.practice;

import java.util.ArrayList;
import java.util.Collections;
public class Playgame {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//定义一个装牌的容器
		ArrayList<String> arrayList = new ArrayList<String>();
		
		//装牌  
		//定义花色数组
		String[] flower= {"♦","♣","♥","♠"};
		String[] number= {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
	
		//将花色和数字进行拼接
		for(String string:flower) {
			for(String num:number) {
				StringBuilder stringBuilder=new StringBuilder();
				arrayList.add(stringBuilder.append(string).append(num).toString());
			}
		}
		arrayList.add("小王");
		arrayList.add("大王");
		
		//洗牌
		Collections.shuffle(arrayList);
		
		//发牌   给每个人发牌   三个玩家的容器
		ArrayList<String> player1=new ArrayList<String>();
		ArrayList<String> player2=new ArrayList<String>();
		ArrayList<String> player3=new ArrayList<String>();
		ArrayList<String> dpArrayList=new ArrayList<String>();
		
		//向每个人的容器里面加牌
		for(int i=0;i<arrayList.size();i++) {
			String string=arrayList.get(i);
			if(i>=arrayList.size()-3) {
				dpArrayList.add(string);
			}else if(i%3==0) {
				player1.add(string);
			}else if(i%3==1) {
				player2.add(string);
			}else {
				player3.add(string);
			}
			
		}
		
		//看牌
		lookpocker("qqq", player1);
		lookpocker("www", player2);
		lookpocker("eee", player3);
		lookpocker("底牌", dpArrayList);
	}
	public static void lookpocker(String nameString,ArrayList<String> array) {
		System.out.println(nameString+"的牌是：");
		for(String string:array) {
			System.out.print(string + " ");
		}
		System.out.println();
	}
}

I/O流：

File

2. 字节流

2.1 字节流概述

2.2 字节流写数据的三种方式

2.3 字节流写数据如何实现换行和追加写入

2.4 字节流写数据加入异常处理

2.5 字节流读数据

一次读取一个字节数组：

2.6 将一个文件中的内容复制到另外一个中

2.7 案例之复制图片

2.8 缓冲输出流

2.9 案例之复制视频

package weichen.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Digui {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		
		//读
		FileInputStream fileInputStream=new FileInputStream("E:\\software\\src\\2.mp4");
		BufferedInputStream bufferedInputStream=new BufferedInputStream(fileInputStream);
		
		FileOutputStream fileOutputStream=new FileOutputStream("E:\\software\\src\\222.mp4");
		BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(fileOutputStream);
		byte[] bytes=new byte[1024];
		int bu;
		while((bu=bufferedInputStream.read(bytes))!=-1) {
			String string=new String(bytes,0,bu);
			bufferedOutputStream.write(string.getBytes());
		}
		
		fileInputStream.close();
		fileOutputStream.close();
	}
}

3. 字符流

递归

1. 阶乘

多线程

1. 进程(正在运行的程序)

2. 线程

3. 多线程实现方式

package weichen.io;

public class ThreadDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyRunnable myThread=new MyRunnable();
		
		//创建Thread类的对象，把MyRunnable对象作为构造方法的参数
		Thread t1=new Thread(myThread,"1");
		Thread t2=new Thread(myThread,"2");
		Thread t3=new Thread(myThread,"3");
		//Thread t4=new Thread(myThread,"4");
		
		t1.start();
		t2.start();
		t3.start();
	}

}
class MyRunnable implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
	
}

4. 设置和获取线程名称

package weichen.io;

public class ThreadDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyThread t1=new MyThread();
		MyThread t2=new MyThread();	
		t1.setName("线程1");  //Thread类中的方法
		t2.setName("线程2");
		t1.start();
		t2.start();
	}
}
class MyThread extends Thread{   //getName()是Thread中的方法，而MyThread继承了该类，所以可以直接使用该方法
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<100;i++) {
			System.out.println(getName()+":"+i);
		}
	}
}


线程1:0
线程2:0
线程1:1
线程1:2
线程2:1
线程1:3
线程1:4
线程2:2
线程1:5
线程2:3
线程2:4
线程1:6
线程2:5
线程1:7
线程2:6
线程1:8
线程2:7
线程1:9
线程2:8
线程1:10
线程2:9
线程1:11
线程2:10
线程1:12
线程2:11
线程1:13

5 线程调度

6. 线程控制

7. 线程生命周期

8. 线程同步–案例之卖票&同步方法

9.线程同步

9.1 线程安全的类

9.2 Lock锁

10. 生产者消费者

package weichen.io;

public class P_C {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Box box=new Box();
		Procedure procedure=new Procedure(box);
		Customer customer=new Customer(box);
		
		Thread t1=new Thread(procedure,"生产者");
		Thread t2=new Thread(customer,"用户");
		
		t1.start();
		t2.start();
	}

}
class Box{
	private int milk;
	private boolean state=false;
	//取出牛奶
	public synchronized void outMilk() {   //synchronized
		//如果没有牛奶，等待
		if(!state) {
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		//如果有牛奶
		System.out.printf("用户拿到第%d瓶奶",this.milk);
		System.out.println();
		state=false;
		
		notifyAll();     //使用wait()让线程等待，就要用另外一个线程将其唤醒
		
	}
	//放入牛奶
	public synchronized void inMilk(int milk) {
		//如果有奶，就等待
		if(state) {
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		//如果没有牛奶，就生产牛奶
		this.milk=milk;
		System.out.printf("送奶工人将第%d瓶奶放入奶箱",this.milk);
		System.out.println();
		state=true;
		
		notifyAll();
	}
}

class Procedure implements Runnable{
	private Box box;
	public Procedure(Box box) {
		// TODO Auto-generated constructor stub
		this.box=box;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=1;i<=5;i++) {
			box.inMilk(i);
		}
	}	
}

class Customer implements Runnable{
	private Box box;
	public Customer(Box box) {
		// TODO Auto-generated constructor stub
		this.box=box;
		
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
			box.outMilk();
		}		
	}
	
}

11. 面试题之线程池：

网络编程

1.1 网络编程概述

1.2 网络编程三要素之IP地址

1.3 网络编程三要素之端口

1.4 网络编程三要素之协议

1.5 UDP通信原理

1.5.1UDP通信程序

package weichen.io;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class SendDemo {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		//首先要创建一个发送端的对象
		DatagramSocket send_people=new DatagramSocket();		
		
		//建立要传输的数据包
		BufferedReader bReader=new BufferedReader(new InputStreamReader(System.in));
		String lineString;
		while((lineString=bReader.readLine())!=null) {
			if("886".equals(lineString)) {
				break;
			}
			byte[] bys=lineString.getBytes();
			

		//将要发送的数据放入数据包中
		DatagramPacket send_data=new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.35.50"), 10086);
		
		//发送数据包
		send_people.send(send_data);
		
		//关闭发送端
		send_people.close();		
	}
}

1.6 TCP

1.6.1 TCP通信原理

1.6.2 TCP发送数据和接收数据

1.6.3 TCP通信程序练习

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.Socket;


public class Client_TCP {

	public static void main(String[] args) throws IOException {	
				//创建客户端Socket对象
				Socket client_Socket=new Socket(InetAddress.getByName("192.168.35.50"), 10005);
				
				//获取发送数据流，发送数据
				BufferedReader bReader=new BufferedReader(new InputStreamReader(System.in));
				BufferedWriter bWriter=new BufferedWriter(new OutputStreamWriter(client_Socket.getOutputStream()));
				String linString;
				while((linString=bReader.readLine())!=null) {
					if("886".equals(linString)) {
						break;
					}
					bWriter.write(linString);
					bWriter.newLine();
					bWriter.flush();			
				}
	
				//释放资源
				client_Socket.close();
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class Server_TCP {

	public static void main(String[] args) throws IOException, IOException {	
		ServerSocket s_Socket=new ServerSocket(10005);
		
		while(true) {
			Socket socket=s_Socket.accept();
			InputStream i_Stream=socket.getInputStream();
			BufferedReader bReader=new BufferedReader(new InputStreamReader(i_Stream));
			
			String lineString;
			while((lineString=bReader.readLine())!=null) {
				System.out.println(lineString);
			}	
		}
	}
}

Lambda表达式