零基础学习java------day14-----泛型，foreach，可变参数，数组和集合间的转换，Set,Map，
1.泛型（jdk1.5以后出现）
https://www.cnblogs.com/lwbqqyumidi/p/3837629.html#!comments
（1）为什么要用泛型？
限制集合，让它只能存储某种类型的元素，如果不限制，集合（默认Object类型）中想存什么就存什么，这样在取元素的时候就会面临大量强制类型转换，这就很可能出现转换异常，为了解决这个问题，jdk1.5以后就出现泛型
当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。因此，当我们取出集合元素时需要人为的强制类型转化到具体的目标类型，这就很容易很容易出现“java.lang.ClassCastException”异常
（2）泛型概述
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变化量话参数，此时类型也定义成参数形式（可称之为类型形参），然后在使用/调用时传入具体的类型（类型实参），一般用"
（3）泛型定义
a 定义在类上
若类在定义时没有加泛型时，则在创建对象时，不能使用泛型，如下图
此时Box定义时加上泛型，如下
public class GenericDemo {
public static void main(String[] args) {
Box
}
}
class Box
T t; // T的类型是什么由创建对象时确定，如此处T就是Integer类型
public Box(T t) {
this.t = t;
}
public T getT() {
return t;
}
}
注意，类在创建对象时，不加泛型，默认是Object类型
b 定义在方法上（不常用）
用法：方法的逻辑相同，只是数据类型不同，这个时候使用反省方法，泛型写在返回值之前，以Collections中sort方法的源码为例
public static
list.sort(null);
}
用了泛型后，sort方法中List中的参数类型就可以不同
public class GenericDemo {
public static void main(String[] args) {
String str = cast("aaa");
}
public static
return (E)o;// 强制类型转换，向下转型
}
}
c. 泛型定义在接口上
interface A
public void test(E e);
}
// 如果实现的接口没有指定具体的类型，则子类必须泛型下去
class B
public void test(E e) {
} }
// 如果实现的接口给定了具体的类型，子类中用到泛型的地方都必须使用该类型
class C implements A
@Override
public void test(String e) {
} }
（4）泛型通配符
泛型通配符：
泛型通配符
任意类型，如果没有明确，那么就是Object以及任意的java类了
？extends E
向下限定，E及其子类
？super E
向上限定，E及其父类
注意：泛型的通配值只能用在=的左边或者是参数列表上
public class GenericDemo2 {
public static void main(String[] args) {
Collection c1 = new ArrayList
Collection c2 = new ArrayList
Collection c3 = new ArrayList
Collection c4 = new ArrayList
class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}
2. foreach（增强for循环）
简化数组和Collection集合的遍历
格式：
for(元素数据类型 元素名 ：数组或者Collection集合){对元素进行你自己的操作}
好处：简化遍历
注意事项：增强for的目标要判断是否为null
数组遍历
public class ForeachClass {
public static void main(String[] args) {
String[] str = new String[] {"哈","哈"};//当此处的数组为null时就会报java.lang.NullPointerException错误，所以要加验证，如下集合例子
for(String a:str) {
System.out.println(a);
}
}
}
集合的遍历
public class ForeachClass {
public static void main(String[] args) {
List
ps.add(new Person("张三",27));
ps.add(new Person("张一",17));
ps.add(new Person("李四",37));
ps.add(new Person("老王",67));
ps.add(new Person("小红",25));
if(ps!=null && ps.size()>0) {
for(Person p:ps) {
System.out.println(p);
}
}
}
}
class Person{
String name;
int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
3. 可变参数
定义方法的时候不知道该定义多少个参数
格式：
修饰符 返回值类型 方法名（数据类型··· 变量名）
注意：
这里的变量其实是一个数组
如果一个方法有可变参数，并且有多个参数，那么，可变参数必须是最后一个（若放前面的话，不能确定哪个参数时不可变参数）
案例
public class ChangeableParamDemo {
public static void main(String[] args) {
System.out.println(getSum(1,2,33));
}
public static int getSum(int b, int…a) { //此变量a为数组
int sum = 0;
System.out.println(b);
for(int i=0;i<a.length;i++) {
sum += a[i];
}
return sum;
}
}
// 运行结果：
1
35
4. 数组和集合间的转换
1.集合转数组;
toArray(collection): 得到 Object[ ]
2.数组转集合：
案例
public class ArrayAndCollection {
public static void main(String[] args) {
List
list.add("老王");
list.add("小明");
//1 集合转数组
Object[] o = list.toArray();
System.out.println(o);
//2 数组转集合
String[] str = {"1","2"};
List
System.out.println(list1 instanceof List);//true
}
}
注意，使用alist得到的集合是不能进行add和remove操作的（只能是可读的集合，
原因：此处asList返回的是一个ArrayList对象，但这个ArrayList是Arrays里面的内部类，这个类中没有实现增加和删除的方法
如果非要操作，需要创建一个新的集合，把它传入到构造方法中，如下
Integer[] arr = {1,2};
List
List
list2.add(100);
System.out.println(list2);//[1, 2, 100]
5.Set
（1）
特点：Set的元素时无序的（不能使用索引操作元素），元素不可重复
collection：
List(): 有序的，元素可重复
ArrayList
LinkedList：特有方法（增删，获取集合首个和最后一个元素）
Set(): 无序的（不能使用索引操作元素），元素不能重复
HashSet：无法保证存入和取出的顺序
LinkedHashSet：可以保证存入和取出的顺序（链表实现）
TreeSet：有序的（可以对元素排序）
不可重复性的原理：
是由hashCode和equals方法保证的
存放元素的时候，先求出元素的hashCode，如果集合中没有这样的hashCode值，说明该元素在集合中不存在，可以存；有这样的hashCode，再比较equals：如果为true，集合中已经存在噶元素，则不存，如果为false，则可以存。
案例
public class SetDemo {
public static void main(String[] args) {
Set
set.add("小猫警长");
set.add("黑猫警长");
set.add("白猫警长");
set.add("花猫警长");
set.add("白猫警长");
set.add("花猫警长");
set.add("黑猫警长");
set.add("红猫警长");
System.out.println(set);
}
}
// 运行结果：[黑猫警长, 红猫警长, 白猫警长, 花猫警长, 小猫警长]
可见存入的顺序并不有序，若想有序可以使用LinkedHashSet创建对象
（2）Set的遍历（三种方法）
第一种：数组
public class SetDemo {
public static void main(String[] args) {
Set
set.add("小猫警长");
set.add("黑猫警长");
set.add("白猫警长");
set.add("花猫警长");
set.add("红猫警长");
Object[] array = set.toArray();
for(Object s:array) {
System.out.println(s);
}
}
}
第二种：迭代器
Iterator
while(it.hasNext()) {
System.out.println(it.next());
}
第三种（增强for循环）
for(String str :set) {
System.out.println(str);
}
练习：
1. 使用LinkedHashSet填写一个程序，获取10个1至20的随机数，要求随机数不能重复
public class TenNum {
public static void main(String[] args) {
Set
Random r = new Random();
while(set.size()<10) {
int num = r.nextInt(20)+1;
set.add(num);
}
System.out.println(set);
}
}
2. 使用集合去重
public class SetQuChong {
public static void main(String[] args) {
List
list.add(1);
list.add(1);
list.add(2);
list.add(2);
List
System.out.println(list1);
}
public static List
Set
set.addAll(list);
list.clear();
list.addAll(set);
return list;
}
}
// 运行结果：[1,2]
6. Map
6.1 概述
双列集合的跟接口；将键映射到值的对象；一个映射不能包含重复的键，每个键最多只能映射到一个值。
Map接口和Collection接口的不同：
Map是双列的，Colection是单列的
Map的键唯一（值可以不唯一），Collection的子体系只有Set是唯一的
6.2 Map接口的成员方法
V put(K key,V value) 添加元素(返回值是Key上一次对应的Value)
V remove(Object key) 移除key对应的键值对（返回值是value）
void clear() 清空map
boolean containsKey(Object key) 是否包含key
boolean containsValue(Object value) 是否包含value
boolean isEmpty() 是否为空
int size() 键值对的个数
V put(K key,V value) 添加元素(返回值是Key上一次对应的Value)
public class MapDemo {
public static void main(String[] args) {
Map
String re = map.put("a","啊，五环，你比四环多一环");
System.out.println(re);
String re1 = map.put("a","啊，四环，你比五环少一环");
System.out.println(re1);
}
}
//运行结果：
null
啊，五环，你比四环多一环
由结果可知，put的返回值为当次被覆盖的内容（第一次打印的结果为null，相当于第一次添加值将null覆盖）
V remove(Object key) 移除key对应的键值对（返回值是被移除键值对中的value）
System.out.println(map);//{a=啊，四环，你比五环少一环}
String re2 = map.remove("a");
System.out.println(re2);//啊，四环，你比五环少一环
get(key) 方法（可用于遍历）,返回值为key所对应的值
System.out.println(map);//{a=啊，四环，你比五环少一环}
String re3 = map.get("a");
System.out.println(re3);//啊，四环，你比五环少一环
6.3 Hashmap的遍历
第一种 keySet 获取所有key
public class MapDemo {
public static void main(String[] args) {
Map
map.put(1, "小明");
map.put(2, "小红");
map.put(3, "小王");
map.put(4, "小李");
Set
for(Integer key:keySet) {
System.out.println("key:"+key+",value:"+map.get(key));
}
}
}
第二种 entrySet（获取键值对）
Set
for (Entry
System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}
使用迭代器实现：
Iterator
while(it.hasNext()) {
System.out.println(it.next());
System.out.println("key:"+next.getKey()+",value:"+next.getValue());
}
第三种 values：只能得到所有的value
Collection
for (String v :values) {
System.out.println(v);
}
6.4 HashMap的实现原理
使用散列表（由数组和链表组成）或哈希表来实现的（效率高）
数组+链表：元素是链表的数组（主体是数组）
练习：统计一个字符串中各个字符出现的次数
public class StrTimes {
public static void main(String[] args) {
Scanner sc= new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.nextLine();
// 创建map，用来存储数据
Map
// 遍历获取每一个字符
for(int i=0;i
for(Character c:keySet) {
System.out.println("字符"+c+"的次数:"+map.get(c));
}
}
}
手机扫一扫
移动阅读更方便
你可能感兴趣的文章