List 接口存储一组不唯一(可以重复),有序(插入顺序)的对象
01. ArrayList实现了长度可变的数组,在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高
通过看ArrayList的源码得知:
 /**
* Constructs an empty list with an initial capacity of ten.
构造一个初始容量为十的空列表
*/
public ArrayList() {
this(10); 调用带参的构造 参数为10
}
 ArrayList创建的时候,数组初始化长度为10!
List list=new ArrayList(-1);     这句话会运行错误! 看源码得知!
  /**
* Constructs an empty list with the specified initial capacity.
*
* @param initialCapacity the initial capacity of the list
* @exception IllegalArgumentException if the specified initial capacity
* is negative
*/
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0) //参数小于0!会抛出异常信息
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}
List list=new ArrayList();   //初始化长度为10
list.add(1);
.....
list.add(11);   //这时候集合会自动扩容!返回一个新的数组长度 =原数组的长度*1.5+1
看源码得知!
 public void ensureCapacity(int minCapacity) {
modCount++;
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3)/2 + 1;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
}

创建一个新闻实体类

public class News {
private int id; //新闻编号
private String title; //新闻标题 @Override
public String toString() {
return "新闻 [编号=" + id + ", 标题=" + title + "]";
} public News() { //无参构造
super();
}
public News(int id, String title) { //带参构造
super();
this.id = id;
this.title = title;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
} public static void main(String[] args) {
News news=new News();
/*
* 直接输出对象 默认走Object类中的toString()
* News类中重写了这个toString() 就会走本类的!
*/
System.out.println(news);
}
}

创建测试类

public class ArrayListTest {

    public static void main(String[] args) {

        List nums=new ArrayList();
nums.add(1);
nums.add(1);
nums.add(1);
nums.add(1);
System.out.println(nums.size()); /*
* 创建一个ArrayList集合
* 存储不唯一(允许重复),有序的数据!
* ArrayList是实现了可变大小的数组!
* 随机访问和遍历的效率高!
*/
List list=new ArrayList();
//往集合中添加 元素(新闻对象)
News news1=new News(1, "新闻1");
News news2=new News(2, "新闻2");
News news3=new News(3, "新闻3");
list.add(news1);
list.add(news2);
list.add(news3);
//01.打印出集合的长度
System.out.println("新闻集合的大小:"+list.size());
//02.查询下标为2的新闻信息
System.out.println(list.get(2));
//03.删除下标为1的新闻
list.remove(1);
//04.通过对象删除
list.remove(news3);
//05.查询集合中是否包含news3
System.out.println("是否包含news3===>"+list.contains(news3));
//新增加一个对象
list.add(new News(4, "新闻4"));
//06.在指定的位置新增一个对象
list.add(0, new News(5,"新闻5"));
System.out.println("*************************");
//打印新闻的标题
for (int i = 0; i < list.size(); i++) {
/*
* 根据集合的下标获取新闻的信息
* get(int index)返回值是Object
* 必须向下转型为News
*/
News news=(News) list.get(i);
System.out.println(news.getTitle());
}
System.out.println("*************************");
//07.把集合转换成数组
Object[] array = list.toArray();
for (int i = 0; i < array.length; i++) {
News news=(News) array[i];
System.out.println("新闻的标题是:"+news.getTitle());
}
System.out.println("*************************");
//08.通过for加强进行遍历
for (Object object : list) {
News news=(News) object;
System.out.println("新闻的标题是:"+news.getTitle());
}
System.out.println("*************************");
/*
* 09.通过迭代器iterator接口
* 001.next():获取序列中的下一个元素
* 002.hasNext():检查序列中是否还有元素
* 003.remove():删除元素
*/
Iterator it = list.iterator();
//判断集合中是否有下一个元素
while(it.hasNext()){
News news=(News) it.next();
System.out.println("新闻的标题是:"+news.getTitle());
}
//10.清空整个集合
list.clear();
//11.判断集合是否为空
System.out.println("集合是否为空==>"+list.isEmpty());
System.out.println(list.size()); //
}
}

02.LinkedList:采用链表存储方式。插入、删除元素时效率比较高

public class LinkedListTest {

    public static void main(String[] args) {
//创建一个LinkedList集合
LinkedList list=new LinkedList();
//创建几个新闻对象
News news1=new News(1, "新闻1");
News news2=new News(2, "新闻2");
News news3=new News(3, "新闻3");
News news4=new News(4, "新闻4");
//新增数据
list.add(news1); //在一个位置
list.addFirst(news2); //news2会顶替news1在集合中的位置 news1位于第2位
list.addLast(news4); //news4在第三个位置
list.add(news3); //第4个位置
//遍历整个集合
for (Object object : list) {
News news=(News) object; //转换成新闻对象才能调用对应方法
System.out.println("新闻的标题:"+news.getTitle());
}
//通过indexOf(Object o) 获取对象在集合中的下标
int index=list.indexOf(news4);
list.remove(index);//根据下标删除对象
//看是否还包含news4
System.out.println("是否还包含news4==>"+list.contains(news4));
//删除集合中的第一个元素
list.removeFirst();
for (Object object : list) {
System.out.println(object); //不需要强制类型转换 默认走的是重写之后的toString()
}
//获取集合中的第一个元素
News news=(News) list.getFirst();
System.out.println("第一个元素的新闻标题:"+news.getTitle());
//获取集合中的最后一个元素
News newsz=(News) list.getLast();
System.out.println("最后一个元素的新闻标题:"+newsz.getTitle());
}
}

ArrayList和LinkedList的区别

/*
* ArrayList和LinkedList的区别
* ArrayList:采用数组的形式来保存数据!这些数据被放在内存中开辟连续的空间!
* 每个数据的位置都有下标!
* 比如说:
* 现在集合长度为50! 现在想删除下标为2的元素!
* 删除之后,底层还要做什么操作?
* 下标为2之后的元素都要前移??
*
* 现在想在下标为3的位置 新增 元素!
* 下标3的元素之后的数据全部后移??
* 所以 新增,删除效率慢!
* 因为是数组结构,所以遍历,查询效率高!
*
* LinkedList:链表式结构!存储在集合中的每个对象都存放在相互独立的空间!
* 比如说:
* 现在集合长度为50!
* 第1个元素记录第2个元素的位置
* 第2个元素记录第3个元素的位置
* 。。。。
* 第49个元素记录第50个元素的位置
* 我们想删除第3个元素!
* 只需要让 第2个元素记录第4个元素的位置!
* 之后的元素有影响吗? 没有
*
* 在第2个元素和第3个元素之间新增一个元素x
* 这时候只需要 第2个元素 记录x的位置
* x记录第三个元素的位置
* 新增,删除效率高!
* 因为没有下标,所以查询遍历的效率低!
*
*/

set集合

public class SetTest {
/**
*
* Set:
* 01.存贮的是唯一,无需的数据
* 02.hashSet是常用的实现类
* 03.存放的是对象的引用
* HashSet底层是hashMap实现的!
* 01.hashSet在添加一个数据的时候,其实是把这个值当成hashMap的key来进行保存的!
* 02.hashMap地城是通过初始化一个Entry数组来实现key,value保存数据的!
* 03.hashMap中的Entry有四个属性变量! key value next hash
* 04.在hashMap中添加数据的步骤
* 001.对key的hashCode进行hash运算,得到的值就是对应的index
* 002.判断index所指向的数组元素是否为空,如果为空,直接插入数据
* 003.如果不为空,依次查询entry中的next所指定的元素,
* 判断key是否相等,如果相等,直接覆盖
* 004.如果key不相等,通过next变量将值插入Entry数组中
*
*/
public static void main(String[] args) {
Set set = new HashSet();
set.add("1");
set.add(new String("1"));
System.out.println(set.size()); // }
}

public class SetTest {
public static void main(String[] args) {
/*
* Set接口存储的是唯一(不能重复),无序(新增,删除,查询)对象的集合!
* HashSet是Set常用的实现类
* Set存放的是对象的引用
*/
//创建一个Set集合
Set s=new HashSet();
//给集合赋值
s.add(""); //空串
s.add(null); //空值
s.add(new String("abc"));
System.out.println(s.size()); // Set set=new HashSet();
set.add(new News(1, "新闻1"));
set.add(new News(2, "新闻2"));
set.add(new News(3, "新闻3"));
System.out.println(set.size()); //
for (Object object : set) {
System.out.println(object);
} Set set1=new HashSet();
set1.add(new String("abc"));
set1.add(new String("abc"));
set1.add(new String("abc"));
System.out.println(set1.size()); // String a ="abc";
String b =new String("abc");
String c =new String("abc");
System.out.println(a==b); //false
System.out.println(c==b); //false
//具有相同内容的String对象,hashCode是一致的!
System.out.println(b.hashCode()==c.hashCode()); //T String str1="a";
String str2=new String("a");
System.out.println(str1==str2); //false 内存地址不一样
System.out.println(str1.equals(str2)); //true 内容一样
System.out.println(str1.hashCode()==str2.hashCode()); //T
}
}
public class TreeTest {
public static void main(String[] args) {
/*
* 1. HashSet是通过HashMap实现的,TreeSet是通过TreeMap实现的,只不过Set用的只是Map的key
* 2. Map的key和Set都有一个共同的特性就是集合的唯一性.TreeMap更是多了一个排序的功能.
* 3. hashCode和equal()是HashMap用的, 因为无需排序所以只需要关注定位和唯一性即可.
* 4. 由于TreeMap需要排序,所以需要一个Comparator为键值进行大小比较.
*/
Set set1=new HashSet();
set1.add("z");
set1.add("a");
set1.add("y");
set1.add("b");
for (Object object : set1) {
System.out.println(object);
} System.out.println("*******************");
TreeSet set2=new TreeSet(); //自动排序
set2.add("z");
set2.add("a");
set2.add("y");
set2.add("b");
for (Object object : set2) {
System.out.println(object);
}
}
}

map集合

public class MapTest {
public static void main(String[] args) {
/*
* Map 是一个键值对的集合 有 key和 value
* 通过key拿到value的值
* Set中的add()默认底层走的是Map的put()
* 所以key是不允许重复的!
* 也是先判断对象的hashCode,之后equals比较!
*/
Map m=new HashMap();
m.put("1", "嘘");
m.put("1", "嘘");
m.put("1", "嘘");
m.put(new String("1"), "嘘");
System.out.println(m.size()); //
System.out.println("*************************"); /*
* 在集合中 不存在 基本数据类型
* 基本数据类型不是类!
* 只能使用基本数据类型的封装类!
*/
Map map=new HashMap();
News news3=new News(3, "新闻3");
//向集合中增加数据
map.put("1", new News(1, "新闻1")); //这里的 "1" 是String
map.put(2, new News(2, "新闻2")); //这里的2 是 Interger
map.put(3, news3);
map.put(4, new News(4, "新闻4"));
System.out.println("集合的大小:"+map.size()); // 4
//通过map集合中的key取得对应的value
News news = (News) map.get("1");
System.out.println(news);
//根据key删除指定的对象
System.out.println("删除的返回值:"+map.remove(4));
//判断是否存在某个key
System.out.println("是否有某个key:"+map.containsKey(4));
//判断是否存在某个value
System.out.println("是否有某个value:"+map.containsValue(news3));
//得到所有key的集合
Set keySet = map.keySet();
for (Object object : keySet) {
System.out.println(object);
}
//返回所有values的集合
Collection values = map.values();
for (Object object : values) {
System.out.println(object);
}
}
}

java集合框架01的更多相关文章

  1. java集合框架01——总体框架一览

    java集合框架是java提供的工具包,在java.util.*中,这个包中包含了常用的数据结构:集合.数组.链表.栈.队列.映射等.java集合框架主要可以分为四个部分:List列表.Set集合.M ...

  2. Java 集合框架 01

    集合框架· ArrayList 和 Vector 对象数组的概述和使用 * A:案例演示 * 需求:我有5个学生,请把这5个学生的信息存储到数组中,并遍历数组,获取到每个学生的信息 Student[] ...

  3. Java 集合系列 01 总体框架

    java 集合系列目录: Java 集合系列 01 总体框架 Java 集合系列 02 Collection架构 Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例 Java ...

  4. Java集合框架Collection

    转自:http://www.cdtarena.com/javapx/201306/8891.html [plain] view plaincopyprint?01.在 Java2中,有一套设计优良的接 ...

  5. Java集合框架之四大接口、常用实现类

    Java集合框架 <Java集合框架的四大接口> Collection:存储无序的.不唯一的数据:其下有List和Set两大接口. List:存储有序的.不唯一的数据: Set:存储无序的 ...

  6. java集合框架容器 java框架层级 继承图结构 集合框架的抽象类 集合框架主要实现类

    本文关键词: java集合框架  框架设计理念  容器 继承层级结构 继承图 集合框架中的抽象类  主要的实现类 实现类特性   集合框架分类 集合框架并发包 并发实现类 什么是容器? 由一个或多个确 ...

  7. 【转载】Java 集合框架

    http://wangkuiwu.github.io/2012/02/03/collection-03-arraylist/ 网上比较全的Java集合框架教程. 注:transient是Java语言的 ...

  8. Java集合框架之Vector浅析

    Java集合框架之Vector浅析 一.Vector概述: 位于java.util包下的Vector是Java集合框架的重要一员,虽然没有ArrayList那么的常用,但是我们还要对其做相关学习: 1 ...

  9. Java集合框架之LinkedList浅析

    Java集合框架之LinkedList浅析 一.LinkedList综述: 1.1LinkedList简介 同ArrayList一样,位于java.util包下的LinkedList是Java集合框架 ...

随机推荐

  1. 激活office 2013

    1.下载office 2013激活工具:microsoft toolkit 2.解压文件,运行Microsoft Toolkit.exe,选择office,即箭头标识处

  2. linux常用svn命令(转载)

     原地址:http://www.rjgc.net/control/content/content.php?nid=4418       1.将文件checkout到本地目录svn checkout p ...

  3. window.clearInterval与window.setInterval的用法 定时器的设置

    window.setInterval() 功能:按照指定的周期(以毫秒计)来调用函数或计算表达式. 语法:setInterval(code,millisec) code:在指定时间到时要执行的Java ...

  4. 扩展PHP内置的异常处理类

    在try代码块中,需要使用throw语句抛出一个异常对象,才能跳到转到catch代码块中执行,并在catch代码块中捕获并使用这个异常类的对象.虽然在PHP中提供的内置异常处理类Exception,已 ...

  5. 平稳退化,JS和HTML标记分离,极致性能的JavaScript图片库

    index.html <!DOCTYPE html> <html lang="en"> <head> <meta charset=&quo ...

  6. bzoj4171 or 省队集训day3 chess: Rhl的游戏

    [题目描述] RHL最近迷上一个小游戏:Flip it.游戏的规则很简单,在一个N*M的格子上,有一些格子是黑色,有一些是白色.每选择一个格子按一次,格子以及周围边相邻的格子都会翻转颜色(边相邻指至少 ...

  7. MySQL的索引

    MySQL索引 索引:是一种特殊的文件(InnoDB 数据表上的索引是表空间的一个组成部分),它们包含着对数据表里所有记录的引用指针.其可以加快数据读操作,但会使数据写操作变慢:应该构建在被用作查询条 ...

  8. LINUX搭建SVN客户端和多个项目的权限分组管理

    搭建SVN服务,有效的管理代码,以下三步可以快速搞定.1.安装 #yum install subversion 判断是否安装成功 1 #subversion -v svnserve, version ...

  9. h.264 Bi-Predictive Motion Search

    在做B帧的运动预测时,有两组参考图像列表(refList0, refList1),需要进行分别前向预测.后向预测.传统的预测方式是: 对refList0进行前向预测,得到最佳前向ref与mv. 对re ...

  10. HDOJ(HDU) 2061 Treasure the new start, freshmen!(水题、)

    Problem Description background: A new semester comes , and the HDU also meets its 50th birthday. No ...