1. ArrayList:底层实现时数组，线程不安全，效率高。所以，查询快。修改、插入、删除慢。
2.LinkedList:底层实现的链表，线程不安全，效率高。所以，查询慢。修改、插入、删除快。
3. Vector：线程安全，效率低。
一.数组容器方法实现
4. package cn.yulei.opp.collectior;
public class Test02 {
private Object[]elementDate;
private int size;
public int size(){
return size;
}
public Test02(){
this(10);
}
public Test02(int initialCapacity){
if(initialCapacity<0){
try {
throw new Exception();
}catch (Exception e) {
e.printStackTrace();
}
}
elementDate=new Object[initialCapacity];
}
public void mm(Object obj){ //将数组元素赋值给数组容器
ensureCapacity();
elementDate[size++]=obj;
}
//数组扩容 封装方法
private void ensureCapacity(){
if(size==elementDate.length){
Object[]newArray=new Object[size*2+1];
System.arraycopy(elementDate,0, newArray,0,elementDate.length);
elementDate=newArray;
}
}
//获取数组的索引
public Object get(int index){
if(index<0||index>=size){
try {
throw new Exception();
}catch (Exception e) {
e.printStackTrace();
}
}
return elementDate[index];
}
//指定位置删除
public void remove(int index){
rangeCheck(index);
int newnum=size-index-1;
if(newnum>0){
System.arraycopy(elementDate, index+1, elementDate, index, newnum);
}
elementDate[--size]=null;
}
public void remove(Object obj){
for(int i=0;i<size;i++){
if(get(i).equals(obj)){ //底层调用的equals方法而不是==。
remove(i);
}
}
}
public Object set(int index,Object obj){ //修改数组元素
rangeCheck(index);
Objectoldvalue=elementDate[index];
elementDate[index]=obj;
return oldvalue;
}
public void add(int index,Object obj){//数组扩容
rangeCheck(index);
ensureCapacity();
System.arraycopy(elementDate,index,elementDate,index+1,size-index);
size++;
} //数组元素的复制
//index的范围检测 封装方法
private void rangeCheck(int index){
if(index<0||index>=size){
try {
throw new Exception();
}catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Test02tt=new Test02(3);
tt.mm("235");
tt.mm("8897");
tt.mm("7897");
tt.mm("656");
tt.mm("684");
tt.remove(3);
System.out.println(tt.size());
System.out.println(tt.get(2));
}
}
二.链表的实现
1. package cn.yulei.opp.collectior;
public class SxtLinkedList {
private Node first;
private Node last;
private int size;
//容器添加链表
public void add(Object obj){
Node n=new Node();
if(first==null){
n.setPrevious(null);
n.setObj(obj);
n.setNext(null);
first=n;
last=n;
}else{
n.setPrevious(last);
n.setObj(obj);
n.setNext(null);
last.setNext(n);
last=n;
}
size++;
}
public int size(){
return size;
}
//检测索引的封装方法
private void rangecheck(int index){
if(index<0||index>=size){
try {
throw new Exception();
}catch (Exception e) {
e.getStackTrace();
}
}
}
//获取链表中某索引处的节点
public Node node(int index){
Nodetemp=null;
if(first!=null){
temp=first;
for(int i=0;i<index;i++){
temp=temp.next;
}
}
return temp;
}
//获取链表中某索引处的节点的值
public Object get(int index){
rangecheck(index);
Nodetemp=node(index);
if(temp!=null){
return temp.obj;
}
return null;
}
//删除链表中的某索引处的节点
public void remove(int index){
rangecheck(index);
Nodetemp=node(index);
if(temp!=null){
Nodeup=temp.previous;
Nodedown=temp.next;
up.next=down;
down.previous=up;
size--;
}
}
//在链表中某索引处添加节点
public void increase(int index,Object obj){
rangecheck(index);
Nodetemp =node(index);
Nodenewnode=new Node();
newnode.obj=obj;
if(temp!=null){
Nodeup=temp.previous;
up.next=newnode;
newnode.previous=up;
newnode.next=temp;
temp.previous=newnode;
}
}
public static void main(String[] args) {
SxtLinkedList List=new SxtLinkedList();
List.add("456");
List.add("aaa");
List.add("mmm");
// List.remove(1); //调用删除的方法
List.increase(1,"BBB"); //添加方法
System.out.println(List.size());
System.out.println(List.get(1));
}
}
2. package cn.yulei.opp.collectior;
public class Node {
Nodeprevious;
Object obj;
Nodenext;
public Node(){
}
public Node(Node previous, Object obj, Node next) {
super();
this.previous = previous;
this.obj = obj;
this.next = next;
}
public Node getPrevious() {
return previous;
}
public void setPrevious(Node previous) {
this.previous = previous;
}
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
4.Map类
实现map接口的类用来储存键（key）-值（value）对；
Map存放键值对，根据键对象找对应的值对象，键不能重复。
Map接口是实现类有HashMap和TreeMap等
Map类中储存的键-值对通过键来标识，所以键值不能重复；
HashMap:
voidclear()从此映射中移除所有映射关系。
booleancontainsKey(Objectkey)
如果此映射包含对于指定键的映射关系，则返回 true。
从此映射中移除指定键的映射关系（如果存在）。（只是移除了容器中的地址，但是还可以调用）
intsize()返回此映射中的键-值映射关系数。
返回此映射中所包含的键的Set视图。
返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
在此映射中关联指定值与指定键。
5.Set：无序 不可重复
List:有序 可重复
List 可以用For遍历 但set不能（他没有顺序）
Set用迭代器遍历 迭代器两者都能遍历
看w3c中Hashset类
6.数据的存储
看collection包
7.迭代器：Iterator的对象称作迭代器 它本身是一个接口，用以方便的实现对容器内元素的遍历操作。
Iterator接口定义方法如下
Boolean hasNext() 判断是否有元素没有被遍历
Object next() 返回游标当前位置的元素并将游标移到下一位
Void remove() 删除游标左边的元素，在执行next之后再执行 只执行一次
importjava.util.Iterator;
importjava.util.List;
importjava.util.Set;
public class Test1 {
public static void main(String[] args) {
Listlist =newArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
//迭代器的使用 也可以用for中不需要++ 因为next()方法中已经加了
for(Iteratoriter=list.iterator();iter.hasNext();){
Stringstr=(String)iter.next();
System.out.println(str);
}
Setset =newHashSet();
set.add("111");
set.add("222");
set.add("333");
for(Iteratoriter2=set.iterator(); iter2.hasNext();){
Stringr=(String) iter2.next();
System.out.println(r);
}
}
}
8.泛型
（1）概念：泛型就是参数化类型，使用广泛的类型
（2）起因：数据类型不明确：
——装入数据类型都被当做Object数据类型对待，从而“丢失”自己的实际类型。
——获取数据时往往需要转型，效率低容易产生错误。
作用
——安全：在编译的时候检查类型安全。
——省心：所有的强制转换都是自动和隐式的，提高代码的重用率。
（3）声明时使用泛型
字母：T Type表示类型
K V分别代表键值中的key value
E代表Element
（4）使用时确定类型
1.泛型只能使用引用类型，不能基本类型
2.泛型声明时字母不能使用静态属性 静态方法上。
注意：接口中泛型字母只能使用在方法中，不能使用在全局常量中。（接口中全局常量就是静态）
泛型方法： <>返回类型前面
只能访问对象的信息，不能修改信息。
（5）自定义泛型：
子类继承父类：
父类为泛型类：属性方法
要么同时擦除，要么子类大于等于父类的类型。
不能子类擦除，父类泛型
1属性类型：父类中随父类而定。子类中随子类而定。
2.方法重写：随父类而定。
如果不指定类型的话就object类型
父类泛型擦除使用object替换.
如下有几种
（1）子类声明时父类指定具体类属性类型为具体类 方法同理
（2）子类为泛型类，类型在使用时确定。
（3）子类为泛型，父类不指定类型，泛型的擦除，使用object替换。
（4）子类和父类同时擦除.
Java一个文件中只能有个public类在类外的类的不能定义public 父类为public类 子类不能定义为public类
接口泛型：与继承同理
（6）Object类型
编译器警告消除 使用Object泛型
没有泛型的类其类型不完全等于Object,编译时不会类型检查。
9.Hashmap经典存储
For(Stringtemp:StrArray){}
其中StrArray是一个数组
每次遍历此数组，用新建的对象temp保存
Map 的containsKey() 方法来检测数据（value）是否存在, 如果key存在, 则表明已经获取过一次数据, 那么直接返回该 key 在 Map 中的值. 不管是否为 null 都直接返回; 如果 key 不存在, 则去生成或者获取数据, 并放入到 Map 中, 并返回该数据.
package cn.yulei.zidingyi;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* 将字符串存储到Map中
* Key:String
* value:自定义类型
*
* “快递分拣”思路
* 1.为所有的key创建容器
* 之后容器中存放对应的value
* 2.第一次创建容器 ，并存放值value
* 第二次之后，直接使用容器存放值
*/
public class Deme01 {
public static void main(String[] args) {
//2.第一次创建容器 ，并存放值value
// 第二次之后，直接使用容器存放值
String str="this is a cat and that is a mice and where is the food";
//分割字符串
String[] strArrray=str.split("");
//存储到Map中
Map letters =new HashMap();
Letter cols=null;
for (String temp:strArrray){
if (null==(letters.get(temp))){
cols=new Letter();
cols.setCount(1);
letters.put(temp,cols);
}else {
cols.setCount(cols.getCount() +1);
}
}
Set keys=letters.keySet();
for (String key:keys){
Letter col=letters.get(key);
System.out.println("字母"+key+"字母的次数"+col.getCount());
}
}
public static void test01(){
String str="this is a cat and that is a mice and where is the food";
//分割字符串
String[] strArrray=str.split("");
//存储到Map中
Map letters =new HashMap();
for (String temp:strArrray){
/**
* 1.为所有的key创建容器
*/
if (!letters.containsKey(temp)){
letters.put(temp,new Letter());
}
//之后容器中存放对应的value值
Letter col=letters.get(temp);///直接使用容器
col.setCount(col.getCount()+1);
}
//输出map的值
Set keys=letters.keySet();
for (String key:keys){
Letter col=letters.get(key);
System.out.println("字母"+key+"字母的次数"+col.getCount());
}
}
}
（2）//map面向对象存储
Demo类：
package cn.yulei.zidingyi;
import java.util.*;
/**
* 定义一个student类，属性name 姓名， id 班号，score成绩
*定义一个班级类ClassRoom类 ，属性 id 班号，stus 学生列表 ,total 学生总分
* 现在将若干个student对象放入list，请统计出每个班级的总分和平均分，分别打印出来
*/
public class Demo02 {
public static void main(String[] args) {
List list =new ArrayList();
exam(list);
Map rooms=new HashMap();
count(list,rooms);
printscore(rooms);
}
//统计总分
public static void count(List list,Map rooms){
for (Student stu:list){
String id=stu.getId();
Double score=stu.getScore();
//根据班级的编号查看map是否存在该班级 分拣思路
ClassRoom room=rooms.get(id);
if (null==room){//第一次
room=new ClassRoom(id);
rooms.put(id,room);
}
//存储 总分
room.setTotal(room.getTotal()+score);
room.getStus().add(stu);//加入学生
}
}
//打印总分与平均分
public static void printscore(Map rooms){
Set> entrySet=rooms.entrySet();
for (Iterator> it=entrySet.iterator();it.hasNext();){
Map.Entry entry=it.next();
ClassRoom room=entry.getValue();
double aug=room.getTotal()/room.getStus().size();
System.out.println("班级名为"+room.getId()+"总分"+room.getTotal()+"平均分"+aug);
}
}
//现在将若干个student对象放入list
public static void exam(List list){
list.add(new Student("小明","01",90));
list.add(new Student("小张","02",60));
list.add(new Student("小红","01",90));
list.add(new Student("小三","03",100));
list.add(new Student("小五","02",80));
}
}
Student 学生类
package cn.yulei.zidingyi;
public class Student {
private Stringname;
private Stringid;
private double score;
public Student(){
}
public Student(String name, String id,double score) {
this.name = name;
this.id = id;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" +name +'\'' +
", id='" +id +'\'' +
", score=" +score +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
}
ClassRoom班级类：
package cn.yulei.zidingyi;
import java.util.ArrayList;
import java.util.List;
public class ClassRoom {
private Stringid;
private Liststus;//学生列表
private double total;//班级总分
public ClassRoom(){
stus=new ArrayList();//初始化一下stus，方便后面直接添加
}
public ClassRoom(String id) {
this();
this.id = id;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public List getStus() {
return stus;
}
public void setStus(List stus) {
this.stus = stus;
}
public double getTotal() {
return total;
}
public void setTotal(double total) {
this.total = total;
}
}
网友评论