JAVA复习之流程控制、数组、泛型、集合

一、详细教程见: 程序结构(流程控制语句)

二、注意事项：

1、case不可以使用浮点类型
2、如果遇到循环嵌套情况，break语句只会使程序流程跳出包含它的最内层的循环结构，即跳出一层循环
3、break、continue提供了“标签”的功能

三、数组

例题解析：
一个3 x 3的网络，将1到9的数字放入方格，达到能够使得每行每列以及每个对角线的值相加都相同。

public class NineGrids {// 创建NineGrids类
	public static void main(String[] args) {
		// 声明int类型的数组并分配内存（三阶方阵）
		int arr[][] = new int[3][3];
		// 确定数字“1”的位置
		int a = 2;// 第3行的下标
		int b = 3 / 2;// 第2列的下标
		for (int i = 1; i <= 9; i++) {// 给数组赋值
			arr[a++][b++] = i;// 避免数组下标越界
			if (i % 3 == 0) {// 如果i是3的倍数
				a = a - 2;
				b = b - 1;
			} else {// 如果i不是3的倍数
				a = a % 3;
				b = b % 3;
			}
		}
		System.out.println("九宫格：");
		// 遍历数组
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < arr.length; j++) {
				System.out.print(arr[i][j] + " ");// 输出数组中的数据
			}
			System.out.println();// 换行
		}
	}
}

四、泛型

（一）什么是泛型？（使程序可以定义安全的数据类型）

java中的参数化类型被称为泛型，下图为例

（二）定义泛型类

**语法：**类名<类型参数1,类型参数2,…类型参数n>{}

public class Demo<T>{
	T username;
	T method(T t){}
}

（三）泛型的用法

在开发过程中，如果需要动态地指定参数类型，那么就需要使用泛型。

1.定义泛型类时声明多个类型

class method<T1,T2>

2.定义泛型类时声明数组类型

定义泛型类型时也可以声明数组类型

2.集合类声明元素的类型

在集合中应用泛型可以保证集合中元素类型的唯一性。从而提高代码的安全性和可维护性。

（四）泛型如何使用

public class Demo030<T> {
    T bankName; //银行名称
    T time; //存款时间
    T username; //户名
    T cardNum; //卡号
    T currency; //币种
    T inAccount; //存款金额
    T leftAccount; //账户余额
    public static void main(String[] args) {
        Demo030<Object> list = new Demo030<Object>(); //创建一个String类型的BankList对象
        list.bankName = "中国建设银行"; //初始化“银行名称”
        list.time = new Date(); //初始化“存款时间”
        list.username = "赵四"; //初始化“户名”
        list.cardNum = "6666 7777 8888 9996 789"; //初始化“卡号”
        list.currency = "RMB"; //初始化“币种”
        list.inAccount = 8888.00; //初始化“存款金额”
        list.leftAccount = 18888.89; //初始化“账户余额”
        DecimalFormat df = new DecimalFormat("###,###.##"); //创建DecimalFormat对象，用来格式化Double类型的对象
        System.out.println(
                "银行名称：" + list.bankName
                        + "\n存款时间：" + list.time
                        + "\n户　　名：" + list.username
                        + "\n卡　　号：" + list.cardNum
                        + "\n币　　种：" + list.currency
                        + "\n存款金额：" + df.format(list.inAccount)
                        + "\n账户余额：" + df.format(list.leftAccount)
        ); //输出上述信息
    }
}

五、集合类的概述

（一）数组真的好用吗？数组和集合的不同之处？

不好用，因为数组长度是固定的，集合的长度是可变的(像列车一样，可动态的加车厢)，数组既可以存放基本数据类型，又可以存放对象，集合只能存放对象，集合包括（LIst、set和Map集合）

（二）Collection接口的常用方法及说明

（三）List集合

List集合包括List接口以及List接口的所有实现类
①List集合中的元素允许重复，且各元素的顺序就是添加元素的顺序
②用户可以通过索引访问集合中的元素
1、List接口

2、List接口的实现类
①ArrayList以数组的形式保存集合中的元素，能够根据索引位置随机且快速地访问集合中的元素。
②LinkedList以链表结构保存集合中的元素，随机访问集合中元素的性能较差，但向集合中插入元素和删除集合中的元素的性能出色。
List list = new ArrayList<>();
List list2 = new LinkedList<>();

3、Iterator迭代器（优点：遍历集合中所有的元素且执行效率高）


4、案例剖析

import java.util.*;

public class Demo01 {
    public static void main(String[] args) {
        //实例化集合类对象
        List<String> list = new ArrayList<>();
        //向集合中添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("12314213");
        //创建迭代器
        Iterator<String> it = list.iterator();
        //判断是否有下一个元素
        while (it.hasNext()){
            //获取集合中的元素
            String str = it.next();
            //打印
            System.out.println(str);
        }
    }
}

（四）Set集合

Set集合中的元素不按特定的方式排序，只是简单地被放在集合中，且Set集合中的元素不能重复。

1、TreeSet(树集合，存放有序)

2、TreeSet类增加的方法

HashSet类和TreeSet类都是Set接口的实现类，它们都不允许有重复元素。但HashSet类在遍历集合中的元素时是不关心元素的顺序，而TreeSet类则会按自然顺序（升序排列）遍历集合中的元素
3、案例剖析

public class Person implements Comparable {
    int id;
    int age;
    String name;

    @Override
    public int compareTo(Object o) {
        Person p;
        //判断是否为person类
        if(o instanceof Person){
            //强制转换
            p = (Person)o;
        }else{
            //表示传入的参数比我本身要小
            return -1;
        }
        int diff = this.age - p.age;
        if(diff != 0){
            //差值除以本身绝对值，可以得到+1 或者-1的值
            diff = diff / Math.abs(diff);
        }
        return diff;
    }
    public Person(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

public class Demo {
    public static void main(String[] args) {
        Set set = new TreeSet();
        Person p1 = new Person(1,18,"熊猫");
        Person p2 = new Person(2,33,"小明");
        Person p3 = new Person(3,22,"梦缘");
        //添加到集合
        set.add(p1);
        set.add(p2);
        set.add(p3);
        set.add(p3);//重复的元素不会被添加到集合中
        System.out.println(set.size());

        //创建迭代器
        Iterator it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

（五）Map集合

方法：keySet() 返回该集合中的所有key对象形成的set集合
values()返回该集合中所有值对象形成的Collection集合

1、案例剖析一

import java.util.*;
public class HashMapTest {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>(); // 创建Map集合对象
		map.put("ISBN 978-7-5677-8742-1", "Android项目开发实战入门"); // 向Map集合中添加元素
		map.put("ISBN 978-7-5677-8741-4", "C语言项目开发实战入门");
		map.put("ISBN 978-7-5677-9097-1", "PHP项目开发实战入门");
		map.put("ISBN 978-7-5677-8740-7", "Java项目开发实战入门");
		Set<String> set = map.keySet(); // 构建Map集合中所有key的Set集合
		Iterator<String> it = set.iterator(); // 创建Iterator迭代器
		System.out.println("key值：");
		while (it.hasNext()) { // 遍历并输出Map集合中的key值
			System.out.print(it.next() + "　");
		}
		Collection<String> coll = map.values(); // 构建Map集合中所有value值的集合
		it = coll.iterator();
		System.out.println("\nvalue值：");
		while (it.hasNext()) { // 遍历并输出Map集合中的value值
			System.out.print(it.next() + "　");
		}
	}
}

多学俩招：建议使用HashMap类实现Map集合，因为由HashMap类实现的Map集合添加和删除映射关系的效率更高；而且希望Map集合中的元素存在一定的顺序，应该使用TreeMap类实现Map集合。

（六）小结

1、List集合关注的是索引，List集合中的元素是有存放顺序的；
2、Set集合关注的唯一性，它的值不允许重复；
3、Map集合关注的是唯一的标识符(key)，它将唯一的键映射到某个元素；