学习内容：
学习关于Java集合框架的内容（一）
ArrayList
容器的容量"capacity"会随着对象的增加，自动增长
只需要不断往容器里增加英雄即可，不用担心会出现数组的边界问题。
练习
package charactor;
import java.util.ArrayList;
public class TestCollection {
@SuppressWarnings("rawtypes")
public static void main(String[ ] args) {
ArrayList heros = new ArrayList<>();
heros.add(new Hero("盖伦"));
System.out.println(heros.size());
heros.add(new Hero("timo"));
System.out.println(heros.size());
for (int i = 0; i < 5; i++) {
heros.add(new Hero("hero " + i));
}
Hero specialHero = new Hero("special hero");
heros.add(specialHero);
System.out.println(heros.contains(new Hero("hero 1")));
//对于同名的新一对象判定为false
System.out.println(heros.contains(specialHero));
//判定是否存在该对像
//获取指定位置的对象
System.out.println(heros.get(5));
//如果超出了范围，依然会报错
System.out.println(heros.get(6));
System.out.println(heros);
//输出所有ArrayList中的对象
System.out.println("specialHero所处的位置:"+heros.indexOf(specialHero));
System.out.println("新的英雄，但是名字是\"hero 1\"所处的位置:"+heros.indexOf(new Hero("hero 1")));
heros.remove(2);
//删除该下标处的对象
System.out.println("删除下标是2的对象");
System.out.println(heros);
System.out.println("删除special hero");
heros.remove(specialHero);
System.out.println(heros);
System.out.println(heros.size());
//获取ArrayList的大小
Hero hs[] = (Hero[])heros.toArray(new Hero[] {});
//转化为数组
System.out.println("数组:" +hs);
heros.clear();
//清空所有对象
}
}
关于List
ArrayList实现了接口List
常见的写法会把引用声明为接口List类型
对于泛型，我认为就是只能存放指定类型的元素以及其子类的容器，类似于只能存放相同类型的数组，但可以存放的类型可以是某一对象及其子类
package charactor;
import java.util.ArrayList;
import java.util.List;
public class Testc1 {
public static void main(String[] args) {
List heros = new ArrayList();
List<fs> genericheros=new ArrayList<>();
genericheros.add(new Hero("a"));
genericheros.add(new Item());
}
}
public class Item extends fs{
}
public class Hero extends fs{
}
关于遍历
while和for增强型暂且不说
之前从未接触过迭代器遍历
Iterator<Hero> it =heros.iterator();
while(it.hasNext()) {//判断是否还存在下一个对象
Hero h = it.next();//取出并移动至下一个位置
System.out.print(h);
}
for (Iterator<Hero> iterator = heros.iterator(); iterator.hasNext();) {
Hero hero = (Hero) iterator.next();
System.out.println(hero);
}
练习：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Allread {
public static void main(String[] args) {
List<Hero> heros = new ArrayList<Hero>();
for (int i = 0; i < 100; i++) {
heros.add(new Hero("hero name " + i));
}
/*Iterator<Hero> it = heros .iterator();
while(it.hasNext()) {
Hero h = it.next();
}*/
for (int i = 99; i >=0 ; i--) {
if(i%8==0)
heros.remove(i);
}
System.out.print(heros);
}
}
关于LinkedList
LinkedList也实现了List接口，同时还实现了Queue和Deque
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class S_LinkedList {
public static void main(String[] args) {
/*LinkedList<Hero> ll =new LinkedList<Hero>();
ll.addLast(new Hero("hero1"));
ll.addLast(new Hero("hero2"));
ll.addLast(new Hero("hero3"));
System.out.print(ll);
ll.addFirst(new Hero("heroX"));
//添加到开头
System.out.print(ll);
System.out.println(ll.getFirst());
//查看第一个
System.out.println(ll.getLast());
//查看最后一个
System.out.println(ll);
System.out.println(ll.removeFirst());
//删除第一个
System.out.println(ll.removeLast());
//删除最后一个
System.out.println(ll);*/
List ll= new LinkedList<Hero>();
Queue<Hero> q = new LinkedList<Hero>();
System.out.println();
q.offer(new Hero("Hero1"));
q.offer(new Hero("Hero2"));
q.offer(new Hero("Hero3"));
q.offer(new Hero("Hero4"));
System.out.println(q);
Hero h = q.poll();
System.out.println(h);
//取出第一个
System.out.println();
System.out.println(q);
h=q.peek();
//查看第一个
System.out.println(h);
System.out.println(q);
}
}
package charactor;
import java.util.LinkedList;
public class MyStack implements Stack{
LinkedList<Hero> ll =new LinkedList<Hero>();
public void push(Hero h) {
ll.addLast(h);
}
public Hero pull() {
return ll.removeLast();
}
public Hero peek() {
return ll.getLast();
}
public static void main(String args[])
{
MyStack heros = new MyStack();
for(int i = 0; i < 5 ; i++)
{
heros.push(new Hero("hero"+i));
}
for(int i = 0; i < 5 ; i++)
{
System.out.println(heros.pull());
}
}
}
关于二叉树
二叉树之前我们在数据结构中进行过学习，因此相对比较熟悉
package charactor;
import java.util.ArrayList;
import java.util.List;
public class Node {
public Node leftNode;
public Node rightNode;
public Object value;
public void add(Object v) {
if(value == null)
value = v;
else {
if((Integer)v - ((Integer)value)<=0){
if(leftNode == null)
leftNode = new Node();
leftNode.add(v);
}
else {
if(rightNode==null)
rightNode = new Node();
rightNode.add(v);
}
}
}
public List<Object> values() {
List<Object> values = new ArrayList<>();
// 左节点的遍历结果
if (null != leftNode)
values.addAll(leftNode.values());
// 当前节点
values.add(value);
// 右节点的遍历结果
if (null != rightNode)
values.addAll(rightNode.values());
return values;
}
public static void main(String[] args) {
int randoms[]=new int [] {67,7,30,73,10,0,78,81,10,74};
Node roots = new Node();
for(int number : randoms) {
roots.add(number);
}
System.out.println(roots.values());
}
}
练习 Hero类的二叉树
package charactor;
import java.util.ArrayList;
import java.util.List;
public class HeroNode {
public HeroNode leftNode;
public HeroNode rightNode;
public Hero hero;
public void add(Hero h) {
if (null == hero)
hero = h;
else {
if ((Integer) hero.hp - ((Integer) h.hp) <= 0) {
if (null == leftNode)
leftNode = new HeroNode();
leftNode.add(h);
}
else {
if (null == rightNode)
rightNode = new HeroNode();
rightNode.add(h);
}
}
}
public List<Hero> values() {
List values = new ArrayList<>();
if (null != leftNode)
values.addAll(leftNode.values());
values.add(hero.name+" "+hero.hp);
if (null != rightNode)
values.addAll(rightNode.values());
return values;
}
public static void main(String[] args) {
Hero[] heros = new Hero[10];
for(int i = 0;i<10 ;i++) {
heros[i] = new Hero("hero "+i);
heros[i].hp = (int) (Math.random()*100);
System.out.println(heros[i].name+" "+heros[i].hp );
}
HeroNode HeroTree = new HeroNode();
for(Hero h : heros) {
HeroTree.add(h);
}
System.out.println(HeroTree.values());
}
}
关于HashMap
在我认知中先当于通过主键查找对于值的储存方式
package charactor;
import java.util.HashMap;
public class Map1 {
public static void main(String[] args) {
HashMap<String,String> dictionary = new HashMap<>();
dictionary.put("adc", "物理英雄");
dictionary.put("apc", "魔法英雄");
dictionary.put("t", "坦克");
System.out.println(dictionary.get("t"));
HashMap<String,Hero> heroMap = new HashMap<String,Hero>();
heroMap.put("gareen", new Hero("gareen1"));
System.out.println(heroMap);
//key为gareen已经有value了，再以gareen作为key放入数据，会导致原英雄，被覆盖
//不会增加新的元素到Map中
heroMap.put("gareen", new Hero("gareen2"));
System.out.println(heroMap);
//清空map
heroMap.clear();
Hero gareen = new Hero("gareen");
//同一个对象可以作为值插入到map中，只要对应的key不一样
heroMap.put("hero1", gareen);
heroMap.put("hero2", gareen);
System.out.println(heroMap);
}
}
练习
package charactor;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class MapTest {
public static void main(String[] args) {
List<Hero> hs = new ArrayList<>();
System.out.println("初始化开始");
for(int i =0;i<3000000;i++)
{
Hero h = new Hero("hero-"+((int)(Math.random()*9000)+1000));
hs.add(h);
}
HashMap<String,List<Hero>> heroMap = new HashMap<>();
for(Hero h : hs)
{
List<Hero> list = heroMap.get(h.name);
if(list==null)
{
list=new ArrayList<>();
heroMap.put(h.name,list);
}
list.add(h);
}
System.out.println("初始化结束");
System.out.println("开始查找");
findByMap(heroMap);
findByIteration(hs);
}
private static List<Hero> findByMap(HashMap<String,List<Hero>> m)
{
long start =System.currentTimeMillis();
List<Hero> result= m.get("hero-6666");
long end = System.currentTimeMillis();
System.out.printf("通过map查找，一共找到%d个英雄，耗时%d毫秒%n",result.size(),end-start);
return result;
}
关于HashSet
了解到其自身并没有独立的实现，而是在里面封装了一个Map.
运用方法除了没有顺序之外，于List似乎并无太大区别（暂时如此认知
package charactor;
import java.util.HashSet;
import java.util.Iterator;
public class HashSettest {
public static void main(String[] args) {
HashSet<Integer> names = new HashSet<Integer>();
names.add(9);
names.add(5);
names.add(1);
System.out.println(names);
for (Iterator iterator = names.iterator(); iterator.hasNext();) {
Integer i = (Integer) iterator.next();
System.out.println(i);
}
//或者采用增强型for循环
for (Integer i : names) {
System.out.println(i);
}
}
}
练习
package charactor;
import java.util.HashSet;
public class TestSetHash1 {
public static void main(String[] args){
String[] str = new String[100];
for(int i=0;i<100;i++){
char[] ch = new char[2];
for(int j=0;j<2;){
char a = (char)(Math.random()*(122-65)+65);
if(Character.isLetter(a)){
ch[j] = a;
j++;
}
}
str[i] = new String(ch);
}
System.out.println("str内容为");
for(String a:str)
System.out.println(a);
System.out.println("----------------");
HashSet<String> content = new HashSet<>();
HashSet<String> plus = new HashSet<>();
for(int i=0;i<str.length;i++){
if(content.contains(str[i])){
plus.add(str[i]);
}
else{
content.add(str[i]);
}
}
System.out.printf("总共有%d种相同的字符串\n分别为: \n",plus.size());
for(String b:plus)
System.out.println(b);
}
}
关于Collection
了解到Collection是 Set List Queue和 Deque的接口
其余因为教程中未细讲，因此了解得不是很清楚
关于Collections
Collections是一个类，容器的工具类,就如同Arrays是数组的工具类
package charactor;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsTest {
public static void main(String[] args) {
//初始化集合numbers
List<Integer> numbers = new ArrayList<>();
for (int i = 0; i < 10; i++) {
numbers.add(i);
}
System.out.println(numbers);
Collections.reverse(numbers);
//反转
System.out.println(numbers);
Collections.shuffle(numbers);
//混淆
System.out.println(numbers);
Collections.sort(numbers);
// 排序
System.out.println(numbers);
Collections.swap(numbers,0,5);
//交换0和5下标的数据
System.out.println(numbers);
Collections.rotate(numbers,2);
//把集合向右滚动2个单位
System.out.println(numbers);
}
}
练习
package charactor;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class TestCollections {
public static void main(String[] args) {
List<Integer> lt=new ArrayList<>();
for(int i=0;i<10;i++)
lt.add(i);
int n=0;
for(int i=0;i<1000000;i++){
Collections.shuffle(lt);
if(lt.get(0)==3)
if(lt.get(1)==1)
if(lt.get(2)==4)
n++;
}
System.out.printf("%f\n",(float)n/1000000);
}
}
关于ArrayList与HashSet
1.是否有顺序 能否重复
ArrayList: 有顺序 可重复
HashSet: 无顺序 不可重复
练习
package charactor;
import java.util.HashSet;
public abstract class TestListwithHashSet {
public static void main(String[] args){
HashSet<Integer> h1=new HashSet<Integer>();
for(int i=0;i<50;i++){
int j=h1.size();
h1.add((int)(Math.random()*9999));
while(i==h1.size()){
h1.add((int)(Math.random()*9999));
}
}
System.out.print(h1);
}
}
关于ArrayList和LinkedList的区别
我认知中arrayList 是顺序储存结构，类似于顺序链表，而LinkedList则有着队列和双向链表的结构
HashMap和Hashtable的区别
HashMap可以存放 null
Hashtable不能存放null
而关于线程安全此处尚未学因此我不是很清楚
HashSet LinkedHashSet TreeSet
HashSet： 无序
LinkedHashSet： 按照插入顺序
TreeSet： 从小到大排序
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
