文章目录
1. 集合泛型 (列举某几个集合)
泛型：凡是集合中带有<类型>的都属于泛型。
优点：统一类型，减少强制类型转换
1.1 泛型 --> List
创建一个List集合，只能<String>泛型
package javase.jingjie.泛型;
/**
* 泛型：凡是集合中带有<E>的都属于泛型。
* 1.泛型是一个编译阶段的语法，在编译阶段统一集合中的类型
* 2.优点：统一类型，减少强制类型转换
* */
import java.util.*;
public class GenerTest01 {
public static void main(String[] args) {
// 创建一个List集合，只能存储字符串类型
List<String> strs= new ArrayList<String>();
//添加元素
//报错，存储只能是String类型
//strs.add(12);
strs.add("JACK");
strs.add("COOK");
strs.add("HUGE");
strs.add("STIM");
//遍历
Iterator<String>it=strs.iterator();
while(it.hasNext()) {
String s=it.next();//此时的类型不再是Object
System.out.println(s);//JACK COOK HUGE STIM
}
}
}
1.2 泛型 --> Map
创建Map集合,键值对类型，泛型String和Integer
package javase.jingjie.泛型;
/**
* Map使用泛型：（String key,Integer value）
* 结果：无序不可重复
* 哈密瓜-->14
黄瓜-->4
西瓜-->12
菠萝-->7
* */
import java.util.*;
public class GenerTest02 {
public static void main(String[] args) {
// 创建Map集合,键值对类型，String和Integer
Map<String,Integer>maps= new HashMap<String, Integer>();
maps.put("西瓜",12);
maps.put("黄瓜",4);
maps.put("菠萝",7);
maps.put("哈密瓜",14);
//Map集合遍历,用keySet()方法，key类型是String
Set<String>keys = maps.keySet();
Iterator<String>it = keys.iterator();
while(it.hasNext()) {
String k=it.next();
Integer v=maps.get(k);
System.out.println(k+"-->"+v);
}
}
}
1.3 泛型 -->SortedSet、TreeSet
创建SortedSet集合,全文都是 <Manager> 泛型
package javase.jingjie.泛型;
/**
* SortedSet集合使用泛型，Comparable比较
* 结果：工作，一个月挣3000.0元
工作，一个月挣5000.0元
工作，一个月挣7000.0元
* */
import java.util.*;
public class GenerTest03 {
public static void main(String[] args) {
//创建SortedSet集合,全文都是<Manager>泛型
SortedSet <Manager>ss= new TreeSet<Manager>();
Manager m1= new Manager(5000);
Manager m2= new Manager(3000);
Manager m3= new Manager(7000);
ss.add(m1);
ss.add(m2);
ss.add(m3);
//遍历
Iterator<Manager>it=ss.iterator();
while(it.hasNext()) {
//泛型后变为Manager类型，统一泛型
Manager m=it.next();//原先是Object o=it.next();类型
m.work();
}
}
}
//第一种比较器
class Manager implements Comparable<Manager>{
double sal;
public Manager(double sal) {
this.sal=sal;
}
public String toStrin() {
return sal+" ";
}
public void work() {
System.out.println("工作，一个月挣"+sal+"元");
}
//实现接口Comparable中的方法
public int compareTo(Manager m){
double sal1=this.sal;
double sal2=m.sal;//不需要强制类型转换，用了泛型之后
if(sal1>sal2) {
return 1;
}else if(sal1<sal2) {
return -1;
}else {
return 0;
}
}
}
1.4 泛型 --> 自定义泛型
Myclass<String>
package javase.jingjie.泛型;
/**
* 自定义泛型
* */
public class GenerTest04 {
public static void main(String [] args) {
Myclass<String> mc=new Myclass<String>();
//泛型就是编译器检查类型
mc.m1("JACK");
}
}
//自定义泛型
class Myclass<T>{
public void m1(T t) {
System.out.println(t);
}
}
2. 增强for循环
for（类型 变量：数组名/集合名）{}
package javase.jingjie.泛型;
import java.util.*;
/**
* 关于增强for循环
* 语法：
* for（类型 变量：数组名/集合名）{}
* 集合要想使用增强for循环这种语法，集合需要使用泛型;
* 如果集合不使用泛型，需要用Object类型来定义for循环中的元素
* */
public class ForeachTest01 {
public static void main(String[] args) {
int[] a= {1,2,3,4,5,6};
//增强for循环
//int e代表的是集合或者数组中的每一个元素
for(int e:a) {
System.out.println(e);
}
System.out.println("=============");
//集合使用泛型
Set<String>strs= new HashSet<String>();
strs.add("臧三");
strs.add("李四");
strs.add("王五");
strs.add("虎六");
//遍历 for循环
for(String name:strs) {
System.out.println(name);
}
System.out.println("--------------");
//集合不使用泛型
List l=new ArrayList();
l.add("胡歌");
l.add("郑爽");
l.add("郑伊健");
l.add("刘德华");
for(Object name:l) {//不加泛型的集合，这里的类型必须用Object，因为it.next()是Object类型
System.out.println(name);
}
}
}
package javase.jingjie.泛型;
/**
* 关于增强for的缺点，没有下标
* */
public class ForeachTest02 {
public static void main(String[] args) {
String[] ins= {"音乐","运动","美食","电影"};
StringBuffer sb =new StringBuffer();
for(int i=0;i<ins.length;i++) {
if(i==ins.length-1) {
sb.append(ins[i]);
sb.append("\n");//换行
}else {
sb.append(ins[i]);
sb.append(",");
}
}
//以上的循环就不适用增强for
for(String s:ins) {
sb.append(s);
sb.append(",");
}
//截取字符串
System.out.println(sb.substring(0,sb.length()-1));//substring(a,b)方法从（a,b）区间截取字符串，含有a,不含b
}
}
