先给大家复习一下基础题！！！

Java基础是java初学者的起点，是帮助你从小白入门到精通必学基础课程！

 为初学者而著！

>>" href="https://www.bilibili.com/video/BV1oy4y1H7R6" rel="external nofollow" target="_blank">Java300集>>>适合准备入行开发的零基础员学习Java，基于最新JDK13、IDEA平台讲解的，视频中穿插多个实战项目。每一个知识点都讲解的通俗易懂，由浅入深。不仅适用于零基础的初学者，有经验的程序员也可做巩固学习。

Java基础板块知识：

1. 职业规划
2. 学习方法
3. 泛型、容器
4. 数据结构和算法
5. 智能电话本实战
6. IO流
7. Java介绍
8. 变量、数据类型、运算符
9. IDEA
10. 控制语句、方法、递归算法
11. 面向对象
12. JVM
13. 数组和数据储存
14. JDK
15. 异常机制、可视化
16. 飞机大战项目

配套学习：>>" href="https://www.bilibili.com/video/BV1oy4y1H7R6" rel="external nofollow" target="_blank">Java初学者入门教程>>>

Map集合：

• |——Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。
• |——HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.
• |——TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。

Map集合存储和Collection有着很大不同：

Collection一次存一个元素；Map一次存一对元素。

Collection是单列集合；Map是双列集合。

Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。

特点：要保证map集合中键的唯一性。

1，添加。

• put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。
• void putAll(Map);

2，删除。

• void clear()：清空
• value remove(key) ：删除指定键。

3，判断。

• boolean isEmpty()：
• boolean containsKey(key)：是否包含key
• boolean containsValue(value) ：是否包含value

4，取出。

• int size()：返回长度
• value get(key) ：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。
• Collection values()：获取map集合中的所有的值。

　　5，想要获取map中的所有元素：

　　　　原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

★ 把map集合转成set的方法：

• Set keySet();
• Set entrySet();//取的是键和值的映射关系。
• Entry就是Map接口中的内部接口；

为什么要定义在map内部呢？entry是访问键值关系的入口，是map的入口，访问的是map中的键值对。

取出map集合中所有元素的方式一：keySet()方法。

可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。

　　　　　　Set keySet = map.keySet();

　　　　　　Iterator it = keySet.iterator();

　　　　　　while(it.hasNext()) {

　　　　　　　　Object key = it.next();

　　　　　　　　Object value = map.get(key);

　　　　　　　　System.out.println(key+":"+value);

　　　　　　}

取出map集合中所有元素的方式二：entrySet()方法。

　　　　　　Set entrySet = map.entrySet();

　　　　　　Iterator it = entrySet.iterator();

　　　　　　while(it.hasNext()) {

　　　　　　　　Map.Entry  me = (Map.Entry)it.next();

　　　　　　　　System.out.println(me.getKey()+"::::"+me.getValue());

　　　　　　}

使用集合的技巧：

• 看到Array就是数组结构，有角标，查询速度很快。
• 看到link就是链表结构：增删速度快，而且有特有方法。addFirst； addLast； removeFirst()； removeLast()； getFirst()；getLast()；
• 看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。
• 看到tree就是二叉树，就要想到排序，就想要用到比较。

比较的两种方式：

• 一个是Comparable：覆盖compareTo方法；
• 一个是Comparator：覆盖compare方法。

LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。

集合什么时候用？

当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。

保证唯一，就用Set。不保证唯一，就用List。

Collections：它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。

　　静态方法：

　　　　Collections.sort(list);//list集合进行元素的自然顺序排序。

　　　　Collections.sort(list,new ComparatorByLen());//按指定的比较器方法排序。

　　　　class ComparatorByLen implements Comparator<String>{

　　　　　　public int compare(String s1,String s2){

　　　　　　　　int temp = s1.length()—s2.length();

　　　　　　　　return temp==0?s1.compareTo(s2):temp;

　　　　　　}

　　　　}

• Collections.max(list); //返回list中字典顺序最大的元素。
• int index = Collections.binarySearch(list,"zz");//二分查找，返回角标。
• Collections.reverseOrder();//逆向反转排序。
• Collections.shuffle(list);//随机对list中的元素进行位置的置换。

将非同步集合转成同步集合的方法：Collections中的  

XXX synchronizedXXX(XXX);

List synchronizedList(list);

Map synchronizedMap(map);

原理：定义一个类，将集合所有的方法加同一把锁后返回。

Collection 和 Collections的区别：

Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。

Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。

Arrays：

用于操作数组对象的工具类，里面都是静态方法。

asList方法：将数组转换成list集合。

　　　　String[] arr = {"abc","kk","qq"};

　　　　List<String> list = Arrays.asList(arr);//将arr数组转成list集合。

将数组转换成集合，有什么好处呢？用aslist方法，将数组变成集合；

可以通过list集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set； 

注意（局限性）：数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如add、remove、clear。（会报不支持操作异常UnsupportedOperationException）；

如果数组中存储的引用数据类型，直接作为集合的元素可以直接用集合方法操作。

如果数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。

集合变数组：用的是Collection接口中的方法：toArray();

如果给toArray传递的指定类型的数据长度小于了集合的size，那么toArray方法，会自定再创建一个该类型的数据，长度为集合的size。

如果传递的指定的类型的数组的长度大于了集合的size，那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。

所以，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。

将集合变成数组后有什么好处？限定了对集合中的元素进行增删操作，只要获取这些元素即可。

Jdk5.0新特性：

Collection在jdk1.5以后，有了一个父接口Iterable，这个接口的出现的将iterator方法进行抽取，提高了扩展性。

增强for循环：foreach语句，foreach简化了迭代器。

格式：// 增强for循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器

　　　　for( 元素类型 变量名 : Collection集合 & 数组 ) {

　　　　　　…

　　　　}

高级for循环和传统for循环的区别：

高级for循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。

如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。

高级for循环可以遍历map集合吗？不可以。但是可以将map转成set后再使用foreach语句。

1、作用：对存储对象的容器进行迭代： 数组  collection   map

2、增强for循环迭代数组：

String [] arr = {"a", "b", "c"};//数组的静态定义方式，只试用于数组首次定义的时候

　　　　for(String s : arr) {

　　　　　　System.out.println(s);

　　　　}

3、单列集合 Collection：

　　　　List list = new ArrayList();

　　　　list.add("aaa");

　　　　// 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？能

　　　　for(Object obj : list) {

　　　　　　String s = (String) obj;

　　　　　　System.out.println(s);

　　　　}

4、双列集合 Map：

　　　　Map map = new HashMap();

　　　　map.put("a", "aaa");

　　　　// 传统方式：必须掌握这种方式

　　　　Set entrys = map.entrySet(); // 1.获得所有的键值对Entry对象

　　　　iter = entrys.iterator(); // 2.迭代出所有的entry

　　　　while(iter.hasNext()) {

　　　　　　Map.Entry entry = (Entry) iter.next();

　　　　　　String key = (String) entry.getKey(); // 分别获得key和value

　　　　　　String value = (String) entry.getValue();

　　　　　　System.out.println(key + "=" + value);

　　　　}

// 增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，因为增强for循环只能针对实现了Iterable接口的集合进行迭代；Iterable是jdk5中新定义的接口，就一个方法iterator方法，只有实现了Iterable接口的类，才能保证一定有iterator方法，java有这样的限定是因为增强for循环内部还是用迭代器实现的，而实际上，我们可以通过某种方式来使用增强for循环。

　　　　for(Object obj : map.entrySet()) {

　　　　　　Map.Entry entry = (Entry) obj;  // obj 依次表示Entry

　　　　　　System.out.println(entry.getKey() + "=" + entry.getValue());

　　　　}

5、集合迭代注意问题：在迭代集合的过程中，不能对集合进行增删操作（会报并发访问异常）；可以用迭代器的方法进行操作（子类listIterator：有增删的方法）。

6、增强for循环注意问题：在使用增强for循环时，不能对元素进行赋值；

　　　　int[] arr = {1,2,3};

　　　　for(int num : arr) {

　　　　　　num = 0; //不能改变数组的值

　　　　}

　　　　System.out.println(arr[1]); //2

可变参数（...）：用到函数的参数上，当要操作的同一个类型元素个数不确定的时候，可是用这个方式，这个参数可以接受任意个数的同一类型的数据。

和以前接收数组不一样的是：

以前定义数组类型，需要先创建一个数组对象，再将这个数组对象作为参数传递给函数。现在，直接将数组中的元素作为参数传递即可。底层其实是将这些元素进行数组的封装，而这个封装动作，是在底层完成的，被隐藏了。所以简化了用户的书写，少了调用者定义数组的动作。

如果在参数列表中使用了可变参数，可变参数必须定义在参数列表结尾(也就是必须是最后一个参数，否则编译会失败。)。

如果要获取多个int数的和呢？可以使用将多个int数封装到数组中，直接对数组求和即可。

静态导入：导入了类中的所有静态成员，简化静态成员的书写。

import static java.util.Collections.*;  //导入了Collections类中的所有静态成员

枚举：关键字 enum

问题：对象的某个属性的值不能是任意的，必须为固定的一组取值其中的某一个；

　　解决办法：

1. 在setGrade方法中做判断，不符合格式要求就抛出异常；
2. 直接限定用户的选择，通过自定义类模拟枚举的方式来限定用户的输入，写一个Grade类，私有构造函数，对外提供5个静态的常量表示类的实例；
3. jdk5中新定义了枚举类型，专门用于解决此类问题；
4. 枚举就是一个特殊的java类，可以定义属性、方法、构造函数、实现接口、继承类；

自动拆装箱：java中数据类型分为两种 ： 基本数据类型   引用数据类型(对象)

在 java程序中所有的数据都需要当做对象来处理，针对8种基本数据类型提供了包装类，如下：

　　　　　　int ——> Integer

　　　　　　byte ——> Byte

　　　　　　short ——> Short

　　　　　　long ——> Long

　　　　　　char ——> Character

　　　　　　double ——> Double

　　　　　　float ——> Float

　　　　　　boolean ——> Boolean

jdk5以前基本数据类型和包装类之间需要互转：

基本———引用   Integer x = new Integer(x);

引用———基本   int num = x.intValue();

1、Integer x = 1; x = x + 1;  经历了什么过程？装箱 ——> 拆箱——> 装箱；

2、为了优化，虚拟机为包装类提供了缓冲池，Integer池的大小 —128~127 一个字节的大小；

3、String池：Java为了优化字符串操作 提供了一个缓冲池；

泛型：jdk1.5版本以后出现的一个安全机制。表现格式：< >

好处：

1：将运行时期的问题ClassCastException问题转换成了编译失败，体现在编译时期，程序员就可以解决问题。

2：避免了强制转换的麻烦。

只要带有<>的类或者接口，都属于带有类型参数的类或者接口，在使用这些类或者接口时，必须给<>中传递一个具体的引用数据类型。

泛型技术：其实应用在编译时期，是给编译器使用的技术，到了运行时期，泛型就不存在了。

为什么? 因为泛型的擦除：也就是说，编辑器检查了泛型的类型正确后，在生成的类文件中是没有泛型的。

在运行时，如何知道获取的元素类型而不用强转呢？

泛型的补偿：因为存储的时候，类型已经确定了是同一个类型的元素，所以在运行时，只要获取到该元素的类型，在内部进行一次转换即可，所以使用者不用再做转换动作了。

什么时候用泛型类呢？

当类中的操作的引用数据类型不确定的时候，以前用的Object来进行扩展的，现在可以用泛型来表示。这样可以避免强转的麻烦，而且将运行问题转移到的编译时期。

泛型在程序定义上的体现：

/泛型类：将泛型定义在类上。

　　class Tool<Q> {

　　　　private Q obj;

　　　　public  void setObject(Q obj) {

　　　　　　this.obj = obj;

　　　　}

　　　　public Q getObject() {

　　　　　　return obj;

　　　　}

　　}

　　//当方法操作的引用数据类型不确定的时候，可以将泛型定义在方法上。

　　public <W> void method(W w) {

　　　　System.out.println("method:"+w);

　　}

　　//静态方法上的泛型：静态方法无法访问类上定义的泛型。如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

　　public static <Q> void function(Q t) {

　　　　System.out.println("function:"+t);

　　}

　　//泛型接口.

　　interface Inter<T> {

　　　　void show(T t);

　　}

　　class InterImpl<R> implements Inter<R> {

　　　　public void show(R r) {

　　　　　　System.out.println("show:"+r);

　　　　}

　　}

泛型中的通配符：可以解决当具体类型不确定的时候，这个通配符就是 ?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

泛型限定：

上限：？extends E：可以接收E类型或者E的子类型对象。

下限：？super E：可以接收E类型或者E的父类型对象。

上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。

下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。

泛型的细节：

1、泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是Object类型；

2、使用带泛型的类创建对象时，等式两边指定的泛型必须一致；

原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；

3、等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)；

ArrayList<String> al = new ArrayList<Object>();  //错

//要保证左右两边的泛型具体类型一致就可以了，这样不容易出错。

ArrayList<? extends Object> al = new ArrayList<String>();

al.add("aa");  //错

//因为集合具体对象中既可存储String，也可以存储Object的其他子类，所以添加具体的类型对象不合适，类型检查会出现安全问题。 ？extends Object 代表Object的子类型不确定，怎么能添加具体类型的对象呢？

public static void method(ArrayList<? extends Object> al) {

al.add("abc");  //错

//只能对al集合中的元素调用Object类中的方法，具体子类型的方法都不能用，因为子类型不确定。

　　　　　　}

　　API——— java.lang.System: 属性和行为都是静态的。

　　long currentTimeMillis(); // 返回当前时间毫秒值

　　exit();  // 退出虚拟机

　　Properties getProperties() ;  // 获取当前系统的属性信息

Properties prop = System.getProperties(); //获取系统的属性信息，并将这些信息存储到Properties集合中。 

System.setProperty("myname","毕老师"); //给系统属性信息集添加具体的属性信息

//临时设置方式：运行jvm时，可以通过jvm的参数进行系统属性的临时设置，可以在java命令的后面加入 –D<name>=<value>  用法：java –Dmyname=小明 类名。

String name = System.getProperty("os.name");//获取指定属性的信息

//想要知道该系统是否是该软件所支持的系统中的一个。

　　Set<String> hs = new HashSet<String>();

　　hs.add("Windows XP");

　　hs.add("Windows 7");

　　if(hs.contains(name))

　　System.out.println("可以支持");

　　else

　　System.out.println("不支持");

API——— java.lang.Runtime: 类中没有构造方法，不能创建对象。

但是有非静态方法。说明该类中应该定义好了对象，并可以通过一个static方法获取这个对象。用这个对象来调用非静态方法。这个方法就是 static Runtime getRuntime();

这个Runtime其实使用单例设计模式进行设计。

　　class  RuntimeDemo {

　　　　public static void main(String[] args) throws Exception {

　　　　　　Runtime r = Runtime.getRuntime();

　　　　　　Process p = r.exec("notepad.exe SystemDemo.java"); //运行指定的程序

　　　　　　Thread.sleep(4000);

　　　　　　p.destroy();  //杀掉进程

　　　　}

　　}

API——— java.util.Math: 用于数学运算的工具类，属性和行为都是静态的。该类是final不允许继承。

• static double ceil(double a) ; //返回大于指定数值的最小整数
• static double floor(double a) ; //返回小于指定数值的最大整数
• static long round(double a) ; //四舍五入成整数
• static double pow(double a, double b) ; //a的b次幂
• static double random(); //返回0~1的伪随机数

　　　　public static void main(String[] args) {

　　　　　　Random r = new Random();

　　　　　　for(int x=0; x<10; x++) {

　　　　　　　　//double d = Math.floor(Math.random()*10+1);

　　　　　　　　//int d  = (int)(Math.random()*10+1);

　　　　　　　　int d = r.nextInt(10)+1;

　　　　　　　　System.out.println(d);

　　　　　　}

　　　　}

　　API——— java.util.Date：日期类，月份从0—11；

　　　　/*

　　　　日期对象和毫秒值之间的转换。

　　　　　　1，日期对象转成毫秒值。Date类中的getTime方法。

　　　　　　2，如何将获取到的毫秒值转成具体的日期呢？

　　　　　　　　Date类中的setTime方法。也可以通过构造函数。 

　　　　*/

​
　　　　//日期对象转成毫秒值

　　　　　　Date d = new Date();

　　　　　　long time1 = d.getTime();

　　　　　　long time2 = System.currentTimeMillis(); / /毫秒值。

　　　　//毫秒值转成具体的日期

　　　　　　long time = 1322709921312l;

　　　　　　Date d = new Date();

　　　　　　d.setTime(time);

　　　　/*

​

　　　　将日期字符串转换成日期对象：使用的就是DateFormat方法中的  Date parse(String source) ；　　　　

*/

　　　　public static void method() throws Exception {

　　　　　　String str_time = "2011/10/25";

　　　　　　DateFormat df = new SimpleDateFormat("yyyy/MM/dd"); //SimpleDateFormat作为可以指定用户自定义的格式来完成格式化。

　　　　　　Date d = df.parse(str_time);

　　　　}

　　　　/*

　　　　如果不需要使用特定的格式化风格，完全可以使用DateFormat类中的静态工厂方法获取具体的已经封装好风格的对象。getDateInstance();getDateTimeInstance();　　　

　*/

　　　　Date d = new Date();

　　　　DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);

　　　　df = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);

　　　　String str_time = df.format(d);

//将日期对象转换成字符串的方式：DateFormat类中的format方法。

//创建日期格式对象。 

DateFormat df = new SimpleDateFormat(); //该对象的建立内部会封装一个默认的日期格式。11—12—1 下午1:48

//如果想要自定义日期格式的话。可使用SimpleDateFormat的构造函数。将具体的格式作为参数传入到构造函数中。如何表示日期中年的部分呢？可以必须要参与格式对象文档。 

df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

//调用DateFormat中的format方法。对已有的日期对象进行格式化。

String str_time = df.format(d);

API——— java.util. Calendar：日历类

　　　　public static void method(){

　　　　　　Calendar c = Calendar.getInstance();

　　　　　　System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"

　　　　　　　　　　　　　　　　　　　　　　　　+getNum(c.get(Calendar.DAY_OF_MONTH))+"日"

　　　　　　　　　　　　　　　　　　　　　　　　+"星期"+getWeek(c.get(Calendar.DAY_OF_WEEK)));

　　　　}

　　　　public static String getNum(int num){

　　　　　　return num>9 ? num+"" : "0"+num;

　　　　}

　　　　public static String getWeek(int index){

　　　　/*

查表法：建立数据的对应关系.

最好：数据个数是确定的，而且有对应关系。如果对应关系的一方，是数字，而且可以作为角标，那么可以通过数组来作为表。

　　　　*/

　　　　　　String[] weeks = {"","日","一","二","三","四","五","六"};

　　　　　　return weeks[index];

　　　　}

 想要学习更多的知识可以，工众号：编程领域

配套学习：>>" href="https://www.bilibili.com/video/BV1oy4y1H7R6" rel="external nofollow" target="_blank">Java初学者入门教程>>>

实战游戏项目：>>" href="https://www.bilibili.com/video/BV1nQ4y1r7Z5/" rel="external nofollow" target="_blank">大鱼吃小鱼>>>

>>" href="https://www.bilibili.com/video/BV1qL411t7GU/" rel="external nofollow" target="_blank">Java开发扫雷游戏实战项目>>>

>>" href="https://www.bilibili.com/video/BV16U4y1P7nG/" rel="external nofollow" target="_blank">Java制作坦克大战游戏实战项目>>>

>>" href="https://www.bilibili.com/video/BV19f4y1J7HL/" rel="external nofollow" target="_blank">Java开发黄金矿工游戏教程>>>