目录
13.1 集合的概念
集合：用来储存对象的对象，容器
数组是一种基础的集合，但数组存在以下弊端
-
数组长度是固定的，数组扩充时需要复杂的拷贝操作
-
数组在元素的插入和删除时使用不方便
class MyList{ private Object[] os=new Object[3]; private int index; //记录数组中有效元素的个数，同时也是元素的下标范围0-index-1 //把元素o添加到数组的末尾 public void add(Object o){ if (os.length == index)expand(); os[index]=o; index++; } //把元素o插入到数组pos下标上 public void add(int pos, Object o){ if (os.length == index)expand(); for (int i = index; i >pos; i--) { os[i]=os[i-1]; } os[pos]=o; index++; } //扩容， private void expand(){ Object []os2=new Object[os.length*2]; for (int i = 0; i < os.length; i++) { os2[i]=os[i]; } os=os2; } //获得数组中有效元素的个数 public int size(){ return index; } //获得数组中pos下标的元素 public Object get(int pos){ return os[pos]; } }集合：对基础数据结构的封装，由java类库提供
13.2集合的组成
Collection
-
接口特点：元素是对象（Object）
-
常用方法
方法 说明 add（Object o） 把对象o放入集合 addAll(Collection c) 把集合c中的所有元素放入当前集合 clear（） 清空集合 contains（Object o） 判断集合中是否存在元素o remove（Object o） 在当前集合中删除元素o size（） 获取集合的长度 toArray（） 将当前集合转换为Object[] forEach() 遍历当前集合 -
遍历：
-
迭代遍历(陈旧)
list中的元素类型为String Iterator<String> it = list.iterator(); while(it.hasNext()){ String s=it.next(); System.out.println(s.toUpperCase()); } -
for-each JDK5
for(String s : list){ //把集合中的所有元素存到s里 System.out.println(s.toUpperCase()); } -
自遍历 JDK8
//匿名内部类 list.forEach(new Consumer<Strinh>() { @Override public void accept(String s) { System.out.println(s.toUpperCase); } }); //lambda list.forEach(o -> System.out.println(s.toUpperCase));
-
-
实现类：无 没有直接的实现类
List Collection的子接口
-
接口特点：元素是有顺序，有下标的。元素可以重复
-
常用方法：
方法 说明 add（int pos,Object o） 把元素o插入到当前集合的pos下标上 get（int pos） 获得集合中pos下标的元素 indexOf（Object o） 获得元素o在集合中的下标，如果不存在，返回-1 remove（int pos） 删除集合中pos下标的元素 set（int pos，Object o） 把元素o设置到当前集合的pos下标上 -
遍历
-
下标遍历
//下标遍历 for (int i = 0; i < list.size(); i++) { String s =list.get(i); System.out.println(s.toUpperCase()); } -
迭代遍历
-
for-each遍历
-
自遍历 forEach(）方法
-
-
实现类
-
ArrayList 数组实现 查询快 增删慢 JDK1.2 线程不安全 并发效率高
-
LinkedList 链表实现 查询慢 增删快
-
Vector 数组实现 JDK1.0 线程安全 并发效率低
-
Set Collection的子接口
-
接口特点：元素是无顺序的，无下标的。元素内容不可重复
-
常用方法：无
-
遍历
-
迭代遍历
-
for-each遍历
-
自遍历 forEach(）方法
-
-
实现类
-
HashSet 底层存储结构：链表数组
如果将自定义的对象放入HashSet，为了保证元素内容不重复
-
覆盖equals方法，保证内容相同的对象返回true
-
覆盖hashCode方法，保证内容相同的的对象返回相同的整数
-
为了哈希表实现最优性能，尽量保证不同对象返回不同的整数
-
-
LinkedHashSet HashSet的子类 元素在遍历时，能按照元素的添加顺序去遍历
-
TreeSet 自动对元素排序，根据排序规则过滤重复元素
-
Map
-
接口特点：元素 是键值对 key键对象 无顺序，内容不可重复 value 值对象 可以重复
-
常用方法：
方法 说明 put（K key， V value） 把key-value键值对放入Map，如果key已经存在，新的value覆盖原有的value V get（K key） 查找key所对相应的value containsKey(K key) 判断Map中是否存在key这个键 containsValue(V value) 判断Map中是否存在value这个值 size() 返回Map的长度 键值对的个数 remove(K key) 删除key所对应的键值对 Set keySet（） 返回Map中所有的key的集合 Collection<v> values（） 返回Map中所有的value的集合 forEach（） 遍历Map -
遍历：
-
keySet 遍历所有的key组成的Set
//键遍历 Set<Integer> ks = map.keySet(); for (Integer key : ks){ String value =map.get(key); System.out.println(key+" : " +value); } -
values() 遍历所有的value组成的Collection
//值遍历 Collection<String> vs = map.values(); for (String value: vs ) { System.out.println(value); } -
自遍历
//自遍历 map.forEach((k,v)-> System.out.println(k+"---"+v));
-
-
实现类：
-
HashMap 使用Hash算法实现 （链表数组，红黑树）
1.2线程不安全 快 允许用null作为key或value
-
LinkedHashMap HashMap的子类，维护键值对的添加顺序
-
TreeMap 自动对key排序
-
Hashtable 1.0线程安全 慢 不允许用null作为key或value
-
Propertices Hashtable的子类 key和value都是String，通常用于早期的配置文件处理
-
13.3泛型
集合存储的是Object，无法对元素的类型做出约束---------类型不安全
利用泛型，可以约定集合中元素的类型
interface A{
void mi(String s);
Interger m2();
}
interface A<T,V>{
void m1(T s);
V m2();
}
class B implements A<String ,Integer>{
public void m1(String s){}
public Integer m2(){return 0;}
}
class C implements A<Double ,String>{
public void m1(Double s){}
public String m2(){return "abc";}
}
interface List <E>{
void add(E o);
get(int pos);//返回为E类型
}
List<String> ls =new ArrayList<String>();//约定集合中元素的类型必须为String
ls.add("abc");
ls.add("xyz");
// ls.add(12);
String s= ls.get(0);List<type1> ls =new ArrayList<type2>();
type1和type2必须一致，没有多态
List<type1> ls =new ArrayList<>();后面的type2可以省略，由编译器自动推断
练习
package day11;
import java.util.*;
/**
* @author 小白孙佳遥 想杨屎郡了
*/
public class testlianxi {
static double result2 = 0;
public static void main(String[] args) {
Set<Sales> hs =new HashSet<>();
hs.add(new Sales("Zhang3", 20.5,"DeptA"));
hs.add(new Sales("li4", 30.5,"DeptA"));
hs.add(new Sales("wang5", 10.3,"DeptB"));
hs.add(new Sales("zaho6", 10.8,"DeptB"));
hs.add(new Sales("Sunjy",55.2 ,"DeptC"));
hs.add(new Sales("Yangjj",30.5 ,"DeptD"));
hs.add(new Sales("Yangyh", 30.6,"DeptD"));
hs.add(new Sales("HuaLB",20.9 ,"DeptA"));
hs.add(new Sales("HuaLB",20.9 ,"DeptA"));
hs.forEach(s -> System.out.println(s));
//4
double result = 0;
for (Sales s:hs)
{
result +=s.getSale();
}
System.out.println(result);
hs.forEach(s->result2 += s.getSale());
System.out.println(result2);
//no.5
StringBuilder sb= new StringBuilder();
for (Sales s:hs)
{
sb.append(s.getName()).append(',');
}
String names = sb.toString();
names = names.substring(0,names.length()-1);
System.out.println(names);
//no.6
Map<String,Double>map = new HashMap<>();
for (Sales s:hs
) {
String dept=s.getDept();
if(map.containsKey(dept)){
double salestatal=map.get(dept);
salestatal += s.getSale();
map.put(dept,s.getSale());
}
else {
map.put(dept,s.getSale());
}
}
map.forEach((k,v)-> System.out.println("部门："+k+"总销量："+v));
//no7.1
Map<String,String>saleMap = new HashMap<>();
for (Sales s:hs
) {
saleMap.put(s.getName(),s.getDept());
}
Collection<String>vs =saleMap.values();
Set<String>resultSet = new HashSet<>();
resultSet.addAll(vs);
System.out.println(resultSet.size());
resultSet.forEach(s-> System.out.println(s));
//no7.2
Scanner scan=new Scanner(System.in);
String deptName = scan.next();
saleMap.forEach((name,dept)->{
if(dept.equals(deptName))
System.out.println(name);
});
//NO 8
String str = "ABCDEFGAMBNCY";
Set<Character> charSet= new HashSet<>();
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if(!charSet.add(c)) System.out.println(c); //重复元素放不进去
}
//NO 9
Map<String,String>users =new HashMap<>();
str ="liucy=12345,lixx=54321,huxz=0000";
String []ss =str.split(",");
for (String subs :ss){
String[] subss=subs.split("=");
users.put(subss[0],subss[1]);
}
String username = scan.next();
if(users.containsKey(username)) System.out.println(users.get(username));
else System.out.println("用户不存在");
}
}
class Sales{
String name;
double sale;
String dept;
public Sales(String name, double sale, String dept) {
this.name = name;
this.sale = sale;
this.dept = dept;
}
public String getName() {
return name;
}
public double getSale() {
return sale;
}
public String getDept() {
return dept;
}
public String toString(){
StringBuilder sb=new StringBuilder();
return sb.append("name= ").append(name).append("sale = ").append(sale).append("dept= ").append(dept).toString();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Sales sales = (Sales) o;
return Double.compare(sales.sale, sale) == 0 && Objects.equals(name, sales.name) && Objects.equals(dept, sales.dept);
}
@Override
public int hashCode() {
Double d =sale;
return this.name.hashCode() + this.dept.hashCode() + d.hashCode();
}
}
扫一扫
3040
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
