毕向东老师Java视频笔记-集合（未完）

最新推荐文章于 2017-11-08 16:57:07 发布
最新推荐文章于 2017-11-08 16:57:07 发布
阅读量490 收藏 1
点赞数 1
分类专栏： Java笔记 文章标签： 数据结构 linkedlist arraylist class java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shenqidemao/article/details/50764710
版权

集合框架图

List类：有序，可重复–>有一些Collection类没有的方法，因为有脚标
* ArrayList
* LinkedList
* Vector

Set类：无序(存入和取出的顺序不一致)，不可重复–>和Collection的方法一致
* HashSet
* TreeSet

1 使用LinkedList模拟堆数据结构和栈数据结构的存取操作过程

class Que 
{
    private LinkedList link = new LinkedList();
    public void myAdd(Object obj){
        link.addFirst(obj);
    }
    public Object myGet(){
        return link.removeFirst();
    }
    public boolean isNull(){
        return link.isEmpty();
    }
    public static void main(String[] args) 
    {
        Que q = new Que();
        q.myAdd("java01");
        q.myAdd("java02");
        q.myAdd("java03");
        q.myAdd("java04");
        while(!q.isNull())
        {
            System.out.println(q.myGet());
        }
    }
}

2 集合类的遍历：

1 使用Iterator迭代器遍历：

实现过程：

ArryList al = new ArryList();
al.add(obj);
for(Iterator it = al.iterator();it.hasNext();){
    it.next();
}

底层实现，内部类

class ArrayList{
    //ArrayList集合中有多个对象，存放的是它们的引用o1,o2,o3；
    Object o1 = new Object():
    Object o2 = new Object():
    Object o3 = new Object():
        class Itr implements Iterator //内部类实现Iterator接口
        {
            hasNext();
            next();
            remove();//方法。。。
        }
        public Iterator iterator(){
            new Itr();
        }
}

注意在使用对象传递时的安全问题(存入集合中元素均视为Object类型，通常都有向上转型的操作)：

import java.util.*;
class Person
{
    private String name;
    private int age;
    Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public static void main(String[] args) 
    {
        ArrayList al = new ArrayList();
        al.add(new Person("张洪题",28));//ArrayList类的方法add()定义为：boolean add(Object obj),因此，这一步做的动作相当于Object obj = new Person();存在向上转型
        al.add(new Person("徐尚",27));
        al.add(new Person("蒋晨晨",25));

        Iterator i = al.iterator();

        while (i.hasNext())
        {
            Person p = (Person)i.next();//如果直接使用i.next().getName();其中i.next()指的是Object类的对象，而Object类是没有getName()方法的，要想使用Person类的方法，必须向下转型
            System.out.println(p.getName()+"---"+p.getAge()+"岁");
        }
    }
}

2 ListIterator

在Iterator遍历过程中，不能使用集合方法对元素进行增删操作，而Iterator只提供了hasNext(),next(),remove();三种方法，因此对于元素有脚标的ArryList集合，遍历时使用ListIterator迭代器；

3 在集合中存入实际对象

List集合，判断其中元素是否相同，使用的是equals()方法：
1. Object类的equals()方法：比较对象地址值；
2. String类的equals()方法：也是比较对象的地址值，因此对于String str1 = new String(“abc”)和String str2 = new String(“abc”)，使用equals()方法将返回false；
3. 实际开发中，经常重写equals()方法(权限public)：下面这个例子必须会写！
4. List集合中的contains();remove();方法底层都调用了equals();方法！！

import java.util.*;

class Person
{
    private String name;
    private int age;
    Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    String getName(){
        return name;
    }
    int getAge(){
        return age;
    }
    //该equals方法，在e.contains(o)方法使用时才能被隐式调用！-->o==null?e==null : o.equals(e)
    public boolean equals(Object obj){//因为Object类中equals方法是public修饰，为了重写该方法，权限必须覆盖
        if (!(obj instanceof Person))
        {
            return false;//此处应该使用try catch抛出异常；
        }
        Person p = (Person)obj;//向下转型
        return name==p.getName() && age==p.getAge();
    }

}

class EqualsDemo 
{
    public static ArrayList singleElement(ArrayList al){
        //创建一个新的ArrayList集合用于存储单一元素
        ArrayList newAl = new ArrayList();
        Iterator i = al.iterator();
        while (i.hasNext())
        {
            Object obj = i.next();
            if(!newAl.contains(obj)){//contains方法，底层实现也是使用Object类的equals方法；
                newAl.add(obj);
            }
        }
        return newAl;
    }
    public static void main(String[] args) 
    {
        ArrayList al = new ArrayList();
        //其中放入相同的用户，要求剔除
        //思路：创建一个静态方法，用于比较ArrayList中存放的Object类的具体值是否相同，需要重写所存储对象所属类的equals方法；
        al.add(new Person("Zhang Hongti",28));
        al.add(new Person("Xu Shang",27));
        al.add(new Person("Jiang Chenchen",25));
        al.add(new Person("Xu Shang",27));

        al=singleElement(al);

        Iterator i = al.iterator();
        while(i.hasNext()){
            Person p = (Person)i.next();
            System.out.println(p.getName()+"---"+p.getAge());
        }
    }
}

4 HashSet

4.1 在HashSet中存入对象

  1. 不是按照你的存入顺序，而是按照对象的哈希值
  2. HashSet中存放对象引用的哈希值可以相同，这种情况下，会进一步比较是否属于同一个对象，从而确定要不要再集合中放入两个元素；
  3. 也就是说，判断是否在HashSet集合中加入一个不重复元素的步骤是：
    1. 调用hashCode()方法判断哈希值是否相同，不同则直接存入；
    2. 调用equals()方法继续判断，返回false则存入；
    3. **注意：**hashCode()和equals()方法常常需要被改写！不需要调用，使用集合Set类方法的时候从底层隐式调用的；
package com.cityu.collection;

class Demo{
    //重写Object类的hashCode()方法
    public int hashCode(Object obj){
        return 199;
    }
}
public class HashSet {
    public static void main(String[] agrs){
        Demo d1 = new Demo();
        Demo d2 = new Demo();
        System.out.println(d1);//底层调用Object类的toString()方法getClass().getName()+"@"+Integer.toHexString(hashCode());
        System.out.println(d2);
    }
}

5 TreeSet

  • 底层数据结构是二叉树，保证数据唯一性的依据是compareTo方法return 0；
    1. 可以通过让对象所属类实现Comparable接口改写compareTo方法实现特定的排序方式；
    2. 定义一个比较器
/*
 *在TreeSet集合中存入自定义对象，希望按照年龄进行排序
 * 
 * */
package com.cityu.collection;

import java.util.*;

public class TreeSetDemo {
    public static void main(String[] agrs){
        TreeSet ts = new TreeSet();

        ts.add(new Student("Zhang Hongti01", 23));
        ts.add(new Student("Zhang Hongti03", 19));
        ts.add(new Student("Zhang Hongti04", 19));//在主要条件相同的情况下，再去对比下一个条件，否则，会被当做相同元素无法存入集合
        ts.add(new Student("Zhang Hongti05", 40));//向TreeSet中存入的对象必须实现Comparable接口，也就是该对象必须可以进行自然排序

        for(Iterator i = ts.iterator();i.hasNext();){
            Student s = (Student)i.next();
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

class Student implements Comparable
{
    private String name;
    private int age;
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
    public int compareTo(Object obj){
        if(!(obj instanceof Student))
            throw new RuntimeException("Wrong Class!");
        Student str = (Student)obj;
        if(this.age>str.age)
            return 1;
        if(this.age==str.age){
            return this.name.compareTo(str.name);//字符串本身具有比较性，实现了Comparable接口
        }
        return -1;
    }
}

使用定义比较器的方式使用自定义方法排序，必须会写！

/*
 * 使用TreeSet集合对存入其中的字符串，按照其长度排序输出：
 * 使用两种方法：
 * 1. 让字符串对象实现Comparable接口，并重写compareTo()方法；
 * 2. 让TreeSet容器自身具备比较性：定义一个比较器，在构造容器时，初始化该比较器；
 * 对比着两种方法：常用的是使用比较器
 * */
package com.cityu.collection;

import java.util.*;

class SetCompare implements Comparator
{
    public int compare(Object o1,Object o2){
        String str1 = (String)o1;
        String str2 = (String)o2;
        int num = str1.length()-str2.length();
        if(num==0){
            return str1.compareTo(str2);
        }
        return num;
    }
}

public class TreeSetTest {
    public static void main(String[] agrs){
        TreeSet ts = new TreeSet(new SetCompare());

        ts.add("abcd");
        ts.add("abe");
        ts.add("abcdef");
        ts.add("efcd");
        ts.add("bfcd");

        for(Iterator i = ts.iterator();i.hasNext();){
            String string = (String)i.next();
            System.out.println(string);
        }
    }
}

6 Map集合

7. 集合框架的工具类

1. Collections类

2. Arrays类

  • 用于操作数组的工具类
  • asList()方法：
    • 将数组变成List：好处是可以使用集合的思想和方法来操纵数组
class ArrayDemo{
    public static void main(String[] agrs){
        String[] arr = {"abd","cdb","ddd"};
        List<String> list = Arrays.asList(arr);
        System.out.println("arr:"+arr);
        System.out.println("list:"+list);
        System.out.println("contains:abd?"+list.contains("abd"));
    }
}

输出：
arr:[Ljava.lang.String;@100363
list:[abd, cdb, ddd]
contains:abd?true

  • 将List变成数组：是为了限制进一步对元素的操作（增删）；
  • 转换时，要确定数组大小：大了，补null；小了，创建新数组；最好是大小刚好：
ArrayList<String> al = new ArrayList<String>();
String[] arr = al.toArray(new String[al.size()]);

3. 迭代器接口（Iterable）

实现Iterable接口的类对象可以成为for-each循环的target：高等级for循环
for(数据类型 变量名：被遍历的集合（Collection）或者数组）

  • 对集合遍历，只能获取元素，不能修改
ArrayList<String> al = new ArrayList<String>();
al.add("abd");
al.add("add");
al.add("fgh");

for(String s:al){
    System.out.println(s);
}

for(String s:al){
    s = "aa";
}
System.out.println(s);

输出：
abd
add
fgh
[abd, add, fgh]

  • 因此，使用迭代器，可以使用remove元素的操作；

  • 如果使用ListIterator，还可以遍历过程中进行增删改查操作；

  • Map集合不能使用，使用keySet()或者entrySet()获得Map中键的Set集合或者键值映射关系Set集合；

HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");

Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
for(Map.Entry<Integer,String> me:entrySet){
    System.out.println(me.getKey()+":"+me.getValue());
}

//或者简写为：
for(Map.Entry<Integer,String> me:hm.entrySet()){
    System.out.println(me.getKey()+":"+me.getValue());
}

4. 可变参数

其实就是数组，不用每次都建立数组对象，只需要将要操作的元素作为参数即可，隐式地将这些元素封装成数组：

{   ...
    varPara(2,3,4,5);
    varPara(3,4,5,6,6,45)
    public static void varPara(int... arr){
        System.out.println(arr);
    }
}
  • 注意：可变参数一定要定义在参数列表的最后面，也就是说在可变参数后面不能继续定义参数

5. staticImport静态导入

对于全部都是静态方法的工具类
import static java.util.Arrays.*;

注意：如果方法重复（通常会和Object类的方法冲突）时，要明确所属类或者对象；

8 常见类：

1. System类：

没有构造函数，全是静态方法，一种工具类。
Properties类是HashTable子类，可以使用Map集合的方法；
System类的getProperties()静态方法，返回Properties子类；

import java.util.*;

public class SystemDemo {
    public static void main(String[] agrs){
        Properties prop = System.getProperties();
        Set<Object> keySet = prop.keySet();
        Iterator<Object> it = keySet.iterator();
        while(it.hasNext()){
            String value = (String)prop.get(it.next());
            System.out.println(value);
        }
        //由于Set集合实现了Iterable接口，因此可以使用for-each高级循环
        for(Object obj:prop.keySet()){
            String value = (String)prop.get(obj);
            System.out.println(value);
        }
    }
}

8.2 Runtime类

Runtime类同样没有构造函数，但是大多是非静态方法，如何调用？

  • 使用getRuntime()静态方法，返回Runtime本类对象，就可以获得对象，从而调用该类方法；(单例设计模式，程序中只存在一个对象)
  • Runtime类方法Process exec(String comand)
public class RuntimeDemo {
    public static void main(String[] agrs) throws Exception
    {
        //Runtime r = Runtime.getRuntime();
        //r.exec("C:\\Program Files\\Tencent\\QQ\\Bin\\QQ.exe");//因为“\”是转义字符
        //杀死本程序启动的进程：无法杀平台进程，因为虚拟机无法拿到平台进程的对象p
        Runtime r = Runtime.getRuntime();
        Process p = r.exec("C:\\Program Files\\Tencent\\QQ\\Bin\\QQ.exe");//因为“\”是转义字符
        Thread.sleep(4000);
        p.destroy();
    }
}

8.3 日期类Date

import java.text.*;//导包
class DateDemo{
    public static void main(String[] agrs){
        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/mm/dd");//创建一个模式对象
        //使用该模式对象调用该类方法对日期对象格式化操作，返回字符串
        String mydate = sdf.format(d);
        System.out.println(mydate);
    }
}

Calender类：获取修改时间，日期等(可以自定义格式)
* 0代表一月

8.4 Math.Random

神气的猫
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
毕向东史上最适合初学者入门的Java基础视频笔记
09-28
毕向东的史上最适合初学者入门的Java基础视频笔记，适合和视频一起使用来辅助学习，里面还有一些本文总结的知识要点
毕向东Java笔记（全部）
weixin_41700993的博客
05-09 2207
文章目录目录DOS命令进制转换数据类型定义变量的格式类型转换转义字符赋值运算符逻辑运算符位运算符 目录 DOS命令 在DOS里新建文件 copy con Demo.java class Demo{ public static void main(String[] args){ System.out.println("Hello Java"); } } Ctrl+Z 保存 type Demo...
毕向东25天的所有教程过程详细笔记
10-05
毕向东25天教程好 非常详细 让人一看就了解很多相对应的知识 怎么样 这笔记非常详细
毕向东java经典学习笔记word版
11-02
毕向东，java经典笔记
最全毕向东java笔记
03-02
传智播客毕向东java笔记，比较全面，毕向东老师上课的代码，总结基本都有，分享给大家。
毕向东视频Java基础笔记.txt
05-18
Java基础笔记 变量 面向对象 异常 多线程 原理 经验总结 内部类 接口
毕向东Java SE视频教程整理笔记
03-08
### 毕向东Java SE视频教程整理笔记 #### 第一章：编程基础 - **Java的特性和优势**：Java语言具有多种特性，包括简单性、面向对象、可移植性（一次编写，到处运行）、高性能、分布式、动态性、多线程、安全性以及...
毕向东_Java基础课堂笔记.pdf
04-21
### 毕向东_Java基础课堂笔记知识点梳理 #### 第一章 编程基础 - **Java的特性和优势** - **简单性**：Java的设计使得语法清晰、简洁，易于学习和理解。 - **面向对象**：支持封装、继承、多态等面向对象编程...
毕向东老师java全部源代码.rar
04-20
毕向东老师作为知名的Java教育专家，他的课程涵盖了Java编程的基础到进阶知识，旨在帮助学习者掌握这一强大语言的核心概念。 1. **类与对象**：在Java中，一切皆为对象。毕向东老师的源代码可能包括了如何定义类、...
java各知识点详细总结(毕向东笔记整理)
01-30
java各知识点详细总结(毕向东笔记整理)。第一章：编程基础 3-11 第二章：数组 11 -31 第三章：面向对象程序开发 31 -74 第四章：异常机制 74 -89 第五章：多线程技术 89 -122122122 第六章：常用类 API 122API 122 API 122API 122API 122API 122API 122-139139139 第七章：集合框架（容器） +其他类对象使用 139 -199 第八章：IO 流 199 -280 第九章：GUIGUIGUI编程 280 -284 第十章：网络编程 284 -309309309 第十一章：反射机制 310 -315315315 第十二章：正则表达式 315 -3223
[毕向东Java基础视频教程]全程笔记
07-14
这是毕向东老师Java基础视频教程配套的笔记，讲解细致、全面，学习Java，你值得拥有。
毕向东javase35天上课笔记
12-13
这是毕向东 javase 35天 上课 的全部笔记,能够全部看懂,看完 基本上 java基础 就没什么问题了
黑马毕向东笔记
11-26
黑马Java毕向东笔记 ,看视频的时候可以看看这个笔记，
毕向东—Java基础知识总结（超级经典） -.pdf
09-06
写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。 4，代码实现。用具体的java 语言代码把思路体现出来。 学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。
javaSE基础知识(毕向东视频笔记)
小锴的学习笔记
11-08 4088
代码仅仅是你思想的一种体现形式而已。
毕向东Java视频学习笔记【Day10 多态+内部类】
ACMer_Shadow的博客
06-24 1771
Java_Day10 多态+内部类   .01 .02 多态 猫 x = new 猫（）； 动物 x = new 猫（）； 一个对象对应着不同类型。 多态在代码中的体现：父类或者接口的引用指向了其子类的对象。 .03 多态的好处：提高了代码的扩展性，前期定义的代码可以使用后期的内容。 第100行 (animal a)使代码简单，其下面的两个method就可
毕向东Java视频学习笔记【day01-day07】
ACMer_Shadow的博客
06-15 5631
2016年6月6日开始学JAVA    Java_Day01 JVM：虚拟机 JRE：JAVA运行环境  （JVM+类库） JDK：JAVA开发工具包（JRE+JAVA的开发工具）   cd..返回上一层 cd\ 返回根目录 md  新建文件夹 del 删除文件夹 rd  删除文件夹 cls 清屏 set 显示windows所有环境变量   环境变量的使用： JAV
1.Java基础知识点整理（基于毕向东老师）
seaoson
02-03 3047
目录 1.Java基础... 1 Java概述SUN.. 1 Java语言三种技术架构J2EE. 1 Java一些简写JVM.. 1 Java环境变量配置JAVA_HOME. 1 Java名词java. 1 主函数，入口函数... 1 2.Java语言基础... 1 2.1关键字... 1 2.2标识符包、类、变量与函数、常量... 2 2.3注释//.
毕向东Java基础视频学习笔记
"毕向东老师的Java基础视频教程的学习笔记，涵盖了从编程基础到高级特性的一系列内容，包括数组、面向对象、异常处理、多线程、API使用、集合框架、IO流、GUI编程、网络编程、反射机制、正则表达式、HTML、CSS、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值