------- android培训、java培训、期待与您交流！ ----------
02 集合 共性方法
import java.util.*;
/*
1.add方法的参数类型是Object，以便于接受任意类型对象
2.方法中存储的都是对象的引用或者地址
什么是迭代器呢？
其实就是集合的取出元素的方式
*/
class CollectionDemo
{
public static void main(String[] args)
{
//method_2();
//base_method();
get_method();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void base_method()
{
//创建一个集合容器，使用Collection接口的子类：ArrayList
ArrayList al = new ArrayList();
//1,添加元素
al.add("java01");//add()参数类型是Object类型的，因为可以是任意对象
al.add("java02");
al.add("java03");
al.add(4);
sop("原集合："+al);
//2.获取个数，集合长度size();
sop("size="+al.size());
//3.删除元素
al.remove("java02");
sop("改变后的集合："+al);
al.clear();//清空集合
sop(al);
//4.判断集合是否为空
sop("判断元素是否存在"+al.contains("java01"));
sop("判断集合是否为空"+al.isEmpty());
}
public static void method_2()
{
ArrayList al1 = new ArrayList();
al1.add("java01");//add()参数类型是Object类型的，因为可以是任意对象
al1.add("java02");
al1.add("java03");
ArrayList al2 = new ArrayList();
al2.add("java05");//add()参数类型是Object类型的，因为可以是任意对象
al2.add("java06");
al2.add("java04");
al2.retainAll(al1);//取交集，al1中只会保留和al2中相同的元素
sop("al1:"+al1);
sop("al2:"+al2);
}
public static void get_method()
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add(4);
/*Iterator it = al.iterator();//返回的是Iterator接口类型的对象，Iterator是一个集合的内部类
while (it.hasNext())
{
sop(it.next());
}*/
for (Iterator it = al.iterator();it.hasNext();)//这样写不用在迭代结束后还保留it对象，因为it是for循环的一个内部变量，便于内存管理
{
sop(it.next());
}
}
}
14.04 集合框架 List集合共性方法
/*
Collction
--List:元素是有序的，元素可以重复，因为该集合体系有索引
--ArrayLitst:底层是数组结构。特点：线程不同步。默认长度是10，扩展加5 查询快，增删慢
--LinkedList:底层是链表结构 查询慢，增删快
--Vector:1.0版本的东西，1.2版本以后才有集合框架。特点：线程同步，被ArrayList替代了。默认是10，扩展加10
一般用ArrayList，速度比Vector快很多
--Set:元素无序的，元素不可以重复
List:
特有方法，凡是可以操作角标的方法都是该体系特有的方法
增
add(int index, E element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(index);
subList(from,to);
listIterator();
List集合特有的迭代器，ListIterator是Iterator的子接口
在迭代时，不可以通过集合对象的方法操作集合中的元素
因为会发生ConcurrentModificationException并发操作异常
所以，在迭代时，只能用迭代器的方法操作元素，可以Iterator方法是有限的
只能对元素进行判断，取出和删除的操作
如果想要其他的操作如添加，修改等，就需要使用其子接口ListIterator
该接口只能通过List集合listIterator方法 获取
*/
import java.util.*;
class ListDemo
{
public static void main(String[] args)
{
//method();
//演示列表迭代器
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add(4);
sop("原集合是："+al);
ListIterator li = al.listIterator();
while (li.hasNext())
{
Object obj = li.next();
if (obj.equals("java02"))
li.set("java006");
if(obj.equals("java03"))
li.add("new");
sop("obj="+obj);
}
sop(li.hasNext());
sop(li.hasPrevious());
sop("改变后的集合："+al);
//在迭代过程中，准备添加或者删除元素
/*Iterator it = al.iterator();
while (it.hasNext())
{
Object obj = it.next();
if (obj.equals("java02"))
//al.add("java008");//这步操作可能会引起并发访问异常，因为al有两种操作方式，容易产生安全隐患
it.remove();
sop("obj="+obj);//迭代过程中即使删除的元素也会被obj引用，所以也能打印出来，而且Iterator只有三个方法，有局限性
}*/
}
public static void method()
{
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add(4);
sop("原集合是："+al);
//在指定位置添加元素
al.add(1,"java09");
//删除指定位置的元素
//all.remove(2);
//修改元素
al.set(2,"java007");
//通过角标获取元素
//sop("get(1):"+al.get(1));
//sop(al);
//获取所有元素
for (int x = 0;x < al.size();x++)
{
sop("al("+x+")="+al.get(x));
}
Iterator it = al.iterator();
while (it.hasNext())
{
sop(it.next());
}
//通过indexOf获取对象的位置
sop("index="+al.indexOf("java09"));
List sub = al.subList(1,4);
sop("sub="+sub);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
14.07 集合框架 Vector中的枚举
import java.util.*;
/*
枚举就是Vector特有的取出方式
发现枚举和迭代器很像
其实枚举和迭代是一样的
因为枚举的名称和方法都过长
所以被迭代器取代了
*/
class VectorDemo
{
public static void main(String[] args)
{
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
Enumeration en = v.elements();
while (en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
14.08 集合框架 LinkedList
import java.util.*;
/*
LinkedList:特有方法（面试比较多）
addFist();
addLast();
getFirst();
getLast();
获取并删除
removeFirst();
removeFirst();
删除并获取
JDK1.6以后出现了替代方法：
offerFirst();
offerFirst();
peekFirst();
peekLast();如果没有元素，则返回null
pollFirst();
pollLast();如果没有元素，则返回null
*
/
class LinkedDemo
{
public static void main(String[] args)
{
LinkedList link = new LinkedList();
link.addFirst("java01");
link.addFirst("java02");
link.addFirst("java03");
link.addFirst("java04");
sop(link);
sop(link.getFirst());
sop(link.getLast());
sop(link.size());
sop(link.removeFirst());
sop(link.size());
while (!link.isEmpty())
{
sop(link.removeFirst());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
14.09 LinkedList练习
/*
使用LinkedList模拟一个堆栈或者队列数据结构
LIFOFIFO
堆栈：先进后出
队列：先进先出 Queue
*/
import java.util.*;
class Queue
{
private LinkedList link;
Queue()
{
link = new LinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj );
}
public Object myGet()
{
return link.removeFirst();
}
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListTest
{
public static void main(String[] args)
{
Queue q = new Queue();
q.myAdd("java01");
q.myAdd("java02");
q.myAdd("java03");
q.myAdd("java04");
while (!q.isNull())
{
System.out.println(q.myGet());
}
}
}
14.10 集合框架 ArrayList练习
/*
需求：
去除ArrayList中重复的元素
*/
import java.util.*;
class ArrayListTest
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java03");
sop("原容器："+al);
al = singleElements(al);
sop("有去重功能的新容器："+al);
}
public static ArrayList singleElements(ArrayList al)
{
ArrayList newal = new ArrayList();
Iterator it = al.iterator();
while (it.hasNext())
{
Object obj = it.next();
if (!newal.contains(obj))//it.next()每次由hasNext判断之后都得让newal再判断，如果不赋值成临时变量，那么会发生只判断一个元素的情况
newal.add(obj);
}
return newal;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
1502 集合框架 treeset存储自定义对象
/*
Set:无序，不可以重复元素
--HashSet：数据结构是哈希表，线程是非同步的
保证元素唯一性的原理，判断元素的hashCode值是否相同
如果相同，还会继续判断元素的equals方法，是否为true
--TreeSet：可以对Set集合中的元素进行排序
底层数据结构是二叉树
1，保证元素唯一性的依据compareTo方法return 0 。
2，当元素不具备比较性时，或者具备的比较性不是所需要的
这时就需要让集合自身具备比较性
在集合初始化时，就有了比较方式
需求；
往TreeSet集合中存储自定义对象学生
想按照学生的年龄进行排序
记住：排序时，当主要条件相同时，一定判断次要条件
*/
import java.util.*;
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
Iterator it = ts.iterator();
while (it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"::"+stu.getAge());
}
}
}
class Student implements Comparable//该接口强制让学生具备比较性
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if (!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"::compare to::"+s.name);
if (this.age > s.age)
return 1;
if(this.age == s.age)
{
return this.name.compareTo(s.name);
};
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
import java.util.*;
/*
当元素自身不具备比较性，或者具备的比较性不是所需要的
这时需要让容器自身具备比较性
定义了比较器，将比较器做为参数传递给TreeSet集合的构造函数
当两种顺序都存在时，以比较器为主
定义一个类，实现Comparator接口，覆盖compare方法
*/
class TreeSetDemo2
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyCompare());
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
ts.add(new Student("lisi007",21));
Iterator it = ts.iterator();
while (it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"::"+stu.getAge());
}
}
}
class Student implements Comparable//该接口强制让学生具备比较性
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if (!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"::compare to::"+s.name);
if (this.age > s.age)
return 1;
if(this.age == s.age)
{
return this.name.compareTo(s.name);
};
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class MyCompare implements Comparator
{
public int compare(Object o1,Object o2)
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num = s1.getName().compareTo(s2.getName());
if (num == 0)
{
if (s1.getAge() > s2.getAge())
return 1;
if (s1.getAge() == s2.getAge())
return 0;
return -1;
}
return num;
}
}
1504 集合框架--实现Comparator方式排序
import java.util.*;
/*
当元素自身不具备比较性，或者具备的比较性不是所需要的
这时需要让容器自身具备比较性
定义了比较器，将比较器做为参数传递给TreeSet集合的构造函数
当两种顺序都存在时，以比较器为主
定义一个类，实现Comparator接口，覆盖compare方法
*/
class TreeSetDemo2
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyCompare());
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
ts.add(new Student("lisi007",21));
Iterator it = ts.iterator();
while (it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"::"+stu.getAge());
}
}
}
class Student implements Comparable//该接口强制让学生具备比较性
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if (!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"::compare to::"+s.name);
if (this.age > s.age)
return 1;
if(this.age == s.age)
{
return this.name.compareTo(s.name);
};
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class MyCompare implements Comparator
{
public int compare(Object o1,Object o2)
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num = s1.getName().compareTo(s2.getName());
if (num == 0)
{
reture new Integer(s1.getAge()).compareTo(new integer(s2.getAge()));
/*if (s1.getAge() > s2.getAge())
return 1;
if (s1.getAge() == s2.getAge())
return 0;
return -1;*/
}
return num;
}
}
1505TreeSet练习
/*
练习：按照字符串长度排序
字符串本身具备比较性，但是他的比较方式不是所需要的
这时就只能使用比较器
*
/
import java.util.*;
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new StrLenComparator());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha");
Iterator it = ts.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}
}
}
class StrLenComparator implements Comparator
{
public int compare(Object o1,Object o2)
{
String s1 = (String)o1;
String s2 = (String)o2;
/*if (s1.length() > s2.length())
return 1;
if(s1.length() == s2.length())
return 0;
return -1;
*/
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if (num == 0)
{
return s1.compareTo(s2);
}
return num;
}
}
1506
import java.util.*;
/*
泛型：JDK1.5版本以后出现新特性，用于解决安全问题，是一个类型2012-10-21安全机制
好处：
1。将运行时期出现问题ClasscastException转移到了编译时期，提高安全性
2.避免了强制转换
*/
class GenericDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();//定义的时候就定义集合类型，用尖括号
al.add("abc001");
al.add("abc088");
al.add("abcd1");
//al.add(4);//这个添加暴露了安全问题，类型转换异常
Iterator<String> it = al.iterator();
while (it.hasNext())
{
String s = it.next();
System.out.println(s+":"+s.length());
}
}
}
相关推荐
day01_Object类、常用API day02_Collection、泛型 day03_List、Set、数据结构、Collections day04_Map，斗地主案例 day05_异常，线程 day06_线程、同步 day07_等待与唤醒案例、线程池、Lambda...Java基础小节练习题答案
集合—黑马程序员Java学习笔记
Java集合例题、例题源码、PPT教学文档（黑马程序员详细版）
含面向对象，异常处理和常用类，线程技术，集合框架，IO操作，网络编程，文件操作，反射机制，
黑马程序员java培训就业班笔记：day16(集合框架基础总结)
。。。
观看黑马程序员Java零基础视频教学，从60P方法开始总结的知识集合，请使用Xmind打开，如果需要学习请配合视频打开：https://www.bilibili.com/video/BV17F411T7Ao
java面试笔试资料java笔试题大集合及答案题库java笔试题汇总资料188个合集 100家大公司java笔试题汇总.doc 125条常见的java 面试笔试题大汇总.pdf 2011最新整理java经典代码.doc ...黑马程序员入学Java精华总结.pdf
java面试笔试题库java软件设计java笔试题大集合及答案文档资料合集300MB“ 100家大公司java笔试题汇总.doc 125条常见的java 面试笔试题大汇总.pdf 2011最新整理java经典代码.doc ...黑马程序员入学Java精华总结.pdf
Javaweb程序设计任务教程课后习题及答案 黑马程序员【传智播客】 集合整理不易，如果文档有错误请见谅，此次整理只有1、2、3、4、5、6、8、9
WEKA作为一个公开的数据挖掘工作平台，集合了大量能承担数据挖掘任务的机器学习算法，包括对数据进行预处理，分类，回归、聚类、关联规则以及在新的交互式界面上的可视化。2005年8月，在第11届ACM SIGKDD国际会议上...
集合： 70 — 80 题 15 — 18 页 线程： 81 — 90 题 18 — 21 页 IO & Socket： 91 — 95 题 21 — 24 页 二、OOAD & UML： 96 — 101 题 24 — 25 页 三、XML： 102 — 105 题 26 — 29 页 四、SQL： 106 — 109 ...
Ⅲ.Collection集合和Map集合的设计和API使用，以及集合的嵌套 Ⅳ.lambda表达式遍历集合，以及比较器comparator()匿名内部类的使用 V.使用Stream流操纵集合 功能： ①日志框架搭建、系统角色设计 ②首页、登录、商家...
java面试笔试题库java学习比较开发教程互联网公司面试资料大全合集: 100家大公司java笔试题汇总.doc 125条常见的java 面试笔试题大汇总.pdf 2011最新整理java经典代码.doc ...黑马程序员入学Java精华总结.pdf
给大家分享一篇我在学习java过程中...包含常见的面试题：JVM、Java集合、多线程并发、java基础、SSM框架原理、微服务、Netty和RPC、网络、日志、算法、数据结构、加密、分布式算法、机器学习、大数据等知识点，都是干货
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
在本套课程中，将会非常深入、非常详细、非常全面的解读HashMap以及...从底层的数据结构到底层源码分析以及怎样使用提高HashMap集合的效率问题等进行分析。如果掌握本套课程，那么再看其他javase的源码时会觉得很简单。
@学习路线根据黑马程序员学习路线改编 Part1: Java基础&Web基础 Java基础 面向对象思想 集合框架 IO流 多线程与并发 异常处理 网络编程 数据库 MySQL Oracle JDBC C3P0 Druid 前端技术 HTML CSS JavaScript jQuery ...
2. Java基础语法、类型转换、运算符、Scanner 3. 分支结构、循环结构、随机数 4. 数组详解、Debug工具使用 5. 方法详解 6. 编程思维案例 7. 面向对象基础 8. 常用API 9. 综合项目实战 Java加强篇包括： 1. static、...
黑马程序员，b站当之无愧的白嫖课程之王 马士兵老师，马老师的课什么都好就是对我来说太贵难度太大，我有时会蹭直播公开课，蹭书。感兴趣可以支持一下（腾讯课堂） 简要介绍 DesignPatterns 设计模式代码库 ...