黑马程序员-Java API-day14

最新推荐文章于 2024-03-14 20:49:58 发布
最新推荐文章于 2024-03-14 20:49:58 发布
阅读量470 收藏
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yinbolove576/article/details/10281761
版权

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

1、集合类概述

1.为什么出现集合类？

       面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种

2.数组和集合类同事容器，有何不同？

       数组虽然也可以存储对象，但长度是固定的；集合长度是可变的，数组中可以存储基本数据类型，集合只能存储

3.集合类的特点

       集合值用于存储对象，集合长度是可变的，集合可以存储不同类型

4.为什么会出现那么多的容器呢？

因为每一个容器对数据的存储方式都有不同，这个存储方式称之为：数据结构。

 

2、集合框架-迭代器

什么是迭代器呢？其实就是集合的取出元素的

把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素。那么取出方式就被定义成了内部类。而每个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容，判断和取出，那么可以将共性内容进行抽取。

那么这些内部类都符合一个规则：该规则是Iterator.如何获取集合的取出对象呢？

通过一个对外提供的方法：iterator();

import java.util.*;
class CollectionDemo
{
       public static void main(String[] args)
       {
              method_get();
              //method_2();
       }
 
       public static void method_get()
       {
              ArrayList al = new ArrayList();
              al.add("Java01");
              al.add("Java02");
              al.add("Java03");
              al.add("Java04");
 
              /*
              Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。
              while(it.hasNext())
              {
                     sop(it.next());
              }
              */
              //老外眼中的迭代器
              for(Iterator it =al.iterator();it.hasNext(); )
              {
                     sop(it.next());
              }
       }
       public static void method_2()
       {
              ArrayList al1 = new ArrayList();
              al1.add("java01");
              al1.add("java02");
              al1.add("java03");
              al1.add("java04");
 
              ArrayList al2 = new ArrayList();
              al2.add("java01");
              al2.add("java02");
              al2.add("java05");
              al2.add("java06");
 
              //al1.retainAll(al2);//取交集，al1中指挥保留和al2相同的元素。
              al1.removeAll(al2);//去除交集的元素
              sop("al1:"+al1);
              sop("al2:"+al2);
 
       }
       public static void method_base()
       {
              //创建一个集合容器，使用Collection接口的子类ArrayList
              ArrayList al = new ArrayList();
              //1.添加元素
              al.add("java01");
              al.add("java02");
              al.add("java03");
              al.add("java04");
 
              //打印集合
              sop("原集合："+al);
 
              //3.删除元素
              //al.remove("java02");
              //al.clear();//清空集合
 
              //4.判断元素
              sop("java03是否存在："+al.contains("java03"));
              sop("集合是否为空："+al.isEmpty());
 
              //2.获取个数，集合长度
              sop("size:"+al.size());
 
              //打印改变后的集合
              sop(al);
       }
       public static void sop(Object obj)
       {
              System.out.println(obj);
       }
}

小结：

1.add方法的参数类型是Object，以便于接收任意类型的对象。

2.集合中存储的都是对象的引用（地址）


3、集合框架-List集合共性方法

Collection

       |--List:元素是有序的，元素可以重复，因为该集合体系有索引；

              |--ArrayList:底层的数据结构使用的是数组结构，特点：查询速度很快，但是增删稍慢，线程不同步。

              |--LinkedList:底层使用的是链表数据结构，特点：增删速度很快，查询稍慢。

              |--Vector:底层是数组数据结构，线程同步。被ArrayList替代了。

       |--Set:元素是无序的，元素不可以重复，因为该集合体系没有

List：

       特有方法：凡是可以操作角标的方法都是该体系特有的方法。

增

       add(index,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_list();
       }
       public static void method_list()
       {
              ArrayList al = new ArrayList();
              //添加元素
              al.add("java01");
              al.add("java02");
              al.add("java03");
             
              sop("原集合是："+al);
              //在迭代过程中，准备添加或者删除元素
 
              ListIterator li = al.listIterator();
              while(li.hasNext())
              {
                     Objectobj = li.next();
                     if(obj.equals("java02"))
                            //li.add("java009");
                            li.set("java06");
              }
              while(li.hasPrevious())
              {
                     sop(li.previous());
              }
              sop(al);
/*
              Iterator it = al.iterator();
              while(it.hasNext())
              {
                     Objectobj = it.next();
                     if(obj.equals("java02"))
                            it.remove();//将java02的引用从集合中删除
                     sop("obj:"+obj);
              }
              sop(al);
              */
       }
       public static void method()
       {
              ArrayList al = new ArrayList();
              //添加元素
              al.add("java01");
              al.add("java02");
              al.add("java03");
             
              sop("原集合是："+al);
 
              //在指定位置添加元素
              al.add(1,"java09");
              //删除指定位置的元素
              //al.remove(2);
              //修改元素
              //al.set(2,"java007");
              //通过角标获取元素
              sop("get(2):"+al.get(2));
              sop("修改后的集合是："+al);
              //获取所有元素
              for(int x=0; x<al.size(); x++)
              {
                     sop("al("+x+")="+al.get(x));
              }
 
              Iterator it = al.iterator();
              while(it.hasNext())
              {
                     sop("next:"+it.next());
              }
              //通过indexOf获取对象的元素
              sop("index="+al.indexOf("java02"));
 
              List sub = al.subList(1,3);
              sop("sub="+sub);
       }
 
       public static void sop(Object obj)
       {
              System.out.println(obj);
       }
}

4、集合框架-Vector中的枚举

枚举就是Vector特有的取出方式。发现枚举和迭代器很像，其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。

import java.util.*;
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())
              {
                     sop(en.nextElement());
              }
       }
       public static void sop(Object obj)
       {
              System.out.println(obj);
       }
}

5、LinkedList

LinkedList:特有方法：

addFirst();

addLast();

getFirst();

getLast();

获取元素，但不删除元素，如果集合中没有元素，会出现NoSuchElementException

removeFirst();

removeLast();

获取元素，但元素被删除，如果集合中没有元素，会出现


在JDK1.6出现了替代方法。

offerFirst();

offerLast();


peekFirst();

peekLast();

获取元素，但不删除元素，如果集合中没有元素，会返回null.

pollFirst();

pollLast();

获取元素，但是元素被删除，如果集合中没有元素，会返回null

import java.util.*;
class LinkedListDemo
{
       public static void main(String[] args)
       {
              LinkedList link = new LinkedList();
              link.addFirst("java01");
              link.addFirst("java02");
              link.addFirst("java03");
              link.addFirst("java04");
 
              sop(link);
              while(!link.isEmpty())
              {
                     sop(link.removeLast());
              }
       }
       public static void sop(Object obj)
       {
              System.out.println(obj);
       }
}

使用LinkedList模拟一个堆栈或者队列数据结构。

堆栈：先进后出  如同一个杯子

队列：先进先出    First in First out FIFO   如同一个水管。

import java.util.*;
class DuiLie
{
       private LinkedList link;
       DuiLie()
       {
              link = new LinkedList();
       }
       public void myAdd(Object obj)
       {
              link.addFirst(obj);
       }
       public Object myGet()
       {
              return link.removeLast();
       }
       public boolean isNull()
       {
              return link.isEmpty();
       }
}
 
class LinkedListTest
{
       public static void main(String[] args)
       {
              DuiLie dl = new DuiLie();
              dl.myAdd("java01");
              dl.myAdd("java02");
              dl.myAdd("java03");
              dl.myAdd("java04");   
 
              while(!dl.isNull())
              {
                     System.out.println(dl.myGet());
              }
       }
}

 

ArrayList练习

import java.util.*;
class ArrayListTest
{
       public static void main(String[] args)
       {
              ArrayList al = new ArrayList();
              al.add("java01");
              al.add("java01");
              al.add("java02");
              al.add("java01");
              al.add("java03");
              al.add("java02");
              al.add("java03");
 
              sop(al);
              al = singleElement(al);
              sop(al);
       }
       public static ArrayList singleElement(ArrayList al)
       {
              //定义一个临时容器
              ArrayList newAl = new ArrayList();
              Iterator it = al.iterator();
              while(it.hasNext())//在迭代时循环中next调用一次，就要hasNext判断一次。
              {
                     Objectobj = it.next();
                     if(!newAl.contains(obj))
                            newAl.add(obj);
              }
              return newAl;
       }
       public static void sop(Object obj)
       {
              System.out.println(obj);
       }
}

将自定义对象作为元素存到ArrayList集合中，并去除重复元素。比如：存人对象，同姓名同年龄，视为同一个人，为重复元素。

思路：

1.对人描述，将数据封装进人的对象。

2.定义容器，将人存入。

3.取出。

List集合判断元素是否相同，依据是元素的equals方法。

import java.util.*;
class Person
{
       private String name;
       private int age;
       Person(Stringname,int age)
       {
              this.name = name;
              this.age = age;
       }
       public boolean equals(Object obj)
       {
              if(!(obj instanceof Person))
                     returnfalse;
              Person p = (Person)obj;
              System.out.println(this.name+"...."+p.name);
              return this.name.equals(p.name)&& this.age == p.age;
       }
       public String getName()
       {
              return name;
       }
       public int getAge()
       {
              return age;
       }
}
class ArrayListTest2
{
       public static void main(String[] args)
       {
              ArrayList al = new ArrayList();
              al.add(new Person("lisi01",30));
              al.add(new Person("lisi02",32));
              al.add(new Person("lisi02",32));
              al.add(new Person("lisi03",33));
              al.add(new Person("lisi04",35));
              al.add(new Person("lisi04",35));
 
              al = singleElement(al);
              Iterator it = al.iterator();
              while(it.hasNext())
              {
                     Objectobj = it.next();
                     Personp = (Person)obj;//强制转换
                     //Personp = (Person).it.next();
                     sop(p.getName()+"..."+p.getAge());
              }
       }
 
       public static ArrayList singleElement(ArrayList al)
       {
              //定义一个临时容器
              ArrayList newAl = new ArrayList();
 
              Iterator it = al.iterator();
              while(it.hasNext())
              {
                     Objectobj = it.next();
                     if(!newAl.contains(obj))
                            newAl.add(obj);
              }
              return newAl;
       }
       public static void sop(Object obj)
       {
              System.out.println(obj);
       }
}

6、集合框架-HashSet

|--Set:元素是无序（存入和取出的顺序不一定一致），元素不可以重复。

       |--HashSet：底层数据结构是哈希表。

                     HashSet是如何保证元素唯一性的呢？

                     是通过元素的两个方法，hashCode和equals来完成。

                     如果元素的HashCode值相同，才会判断equals是否为true。

                     如果元素的hashcode值不同，不会调用equals。

 

                     注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

       |--TreeSet：

Set集合的功能和Collection是一致的。

import java.util.*;
class HashSetDemo
{
       public static void sop(Object obj)
       {
              System.out.println(obj);
       }
       public static void main(String[] args)
       {
              HashSet hs = new HashSet();
              hs.add("java01");
              sop(hs.add("java02"));
              sop(hs.add("java02"));
              hs.add("java03");
              hs.add("java04");
              hs.add("java04");
 
              Iterator it = hs.iterator();
              while(it.hasNext())
              {
                     sop(it.next());
              }
       }
}

往HashSet集合中存入自定义对象姓名和年龄相同视为同一个人，重复元素

import java.util.*;
class Person
{
       private String name;
       private int age;
       Person(String name,int age)
       {
              this.name = name;
              this.age = age;
       }
       public int hashCode()
       {
              //return 60;
              System.out.println(this.name+"....hashCode");
              return name.hashCode()+age*39;//为了尽量保证hashCode值的唯一
       }
       public boolean equals(Object obj)
       {
              if(!(obj instanceof Person))
                     returnfalse;
              Person p = (Person)obj;
              System.out.println(this.name+"...equals..."+p.name);
              return this.name.equals(p.name)&& this.age == p.age;
       }
       public String getName()
       {
              return name;
       }
       public int getAge()
       {
              return age;
       }
}
class HashSetTest
{
       public static void sop(Object obj)
       {
              System.out.println(obj);
       }
       public static void main(String[] args)
       {
              HashSet hs = new HashSet();
              hs.add(new Person("a1",11));
              hs.add(new Person("a2",12));
              //hs.add(new Person("a2",12));
              hs.add(new Person("a3",13));
              //hs.add(new Person("a3",13));
              //hs.add(new Person("a4",14));
 
              //sop(hs.contains(newPerson("a1",11)));
              hs.remove(new Person("a3",13));
              Iterator it = hs.iterator();
              while(it.hasNext())
              {
                     Personp = (Person)it.next();
                     sop(p.getName()+"..."+p.getAge());
              }
       }
}

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------
详细请查看：http://edu.csdn.net
赤脚浪涯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员-Java语言进阶-源码、教程笔记.zip
12-16
day01_Object类、常用API day02_Collection、泛型 day03_List、Set、数据结构、Collections day04_Map，斗地主案例 day05_异常，线程 day06_线程、同步 day07_等待与唤醒案例、线程池、Lambda表达式 day08_File类、...
黑马-JAVA中州养老项目2024语言汇编
最新发布
05-02
黑马-JAVA中州养老项目2024资源简介： 课程大纲 day01-基础数据开发-服务管理 day02-基础数据开发-服务管理-前端 day03-基础数据开发-预约管理 day04-权限认证-基础 day05-权限认证-SpringSecurity认证授权 ...
黑马程序员-java学习笔记_整理黑马官网Java自学27天基础视频及笔记
weixin_39569894的博客
02-13 1373
本帖最后由 wl756071448 于 2016-2-28 15:25 编辑资料来源于黑马官网及柳柳桑整理笔记！！！希望各位管理员能给点币币咯Java黑马自学基础视频教程链接：http://pan.baidu.com/s/1pJXAjnP 密码：qj48Java黑马自学基础笔记 链接：http://pan.baidu.com/s/1jGUw7Jo 密码：kshq笔记需用第一天视频...
黑马程序员-Java API-day15
yinbolove576的专栏
08-24 410
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 1、集合框架—TreeSet Set无序，不可以重复元素。        |--HashSet：数据结构式哈希表，县城市非同步的。                             保证元素唯一性的原理：判断怨毒
黑马程序员Java笔记
m0_68735537的博客
03-14 1632
输出打印、参与运算、修改记录的值。
黑马程序员-Java API-day17
yinbolove576的专栏
08-24 424
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 集合框架的工具类 1、Collections-sort Collections:此类完全由在collection上进行操作或返回collection的静态方法组成。它包含collection上操作的多态算法，即“包装器”
黑马程序员-瑞吉外卖-day6
m0_59690068的博客
01-29 163
后台系统中可以管理分类信息，分类包括两种类型，分别是 **菜品分类** 和 **套餐分类**。当我们在后台系统中添加菜品时需要选择一个菜品分类，当我们在后台系统中添加一个套餐时需要选择一个套餐分类，在移动端也会按照菜品分类和套餐分类来展示对应的菜品和套餐。
黑马程序员-Java API-day13
yinbolove576的专栏
08-24 401
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 1、String类 1.字符串是一个特殊的对象 2.字符串一旦初始化就不可以被改变。 public finalclass String extends Object，发现final说明该String没有子类，也不能复写
黑马程序员-Java API-day16
yinbolove576的专栏
08-24 367
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 1、Map集合概述 接口Map 类型参数： K：此映射所维护的键的类型 V：映射值的类型 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。   Map集合：该集合存储键值对。一
黑马程序员-瑞吉外卖-day8
m0_59690068的博客
02-18 287
分析：后台系统中可以管理菜品信息，通过 新增功能来添加一个新的菜品，在添加菜品时需要选择当前菜品所属的菜品分类，并且需要上传菜品图片，在移动端会按照菜品分类来展示对应的菜品信息。新增菜品，其实就是将新增页面录入的菜品信息插入到dish表，如果添加了口味做法，还需要向dish_flavor表插入数据。
黑马程序员-常用Java API介绍
jyhonggang13848的专栏
10-29 300
——-android培训java培训期待与您交流!———-String类介绍 字符串是一个特殊的对象。 字符串一旦初始化就不可以被改变。 Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。 String s1 = "abc"与String s2 = new String("abc");s1和s2都是定义一个字符串为”abc”的对象变量。s1是一个类型变量，”abc”是一个对
HeiMaJavaWebVideo:黑马程序员-超全面的JavaWeb教程-原始笔记
03-24
黑马程序员-超全面的JavaWeb教程-原始笔记 HeiMaJavaWebVideo 黑马程序员-超全面的JavaWeb教程继承笔记 Day01 01. README.txt ===>课堂笔记02. Contents.txt ===>课堂目录03. Hello.html ===>演示字体标签和HTML的...
黑马程序员java培训就业班笔记：day10总结JAVA语言
03-26
黑马程序员java培训就业班笔记：day10总结
黑马程序员 hibernate 2017版讲义资料-day2
10-11
黑马程序员 hibernate 2017版讲义资料,包括源码，笔记，图片等。
黑马程序员_06Java_IO流知识总结
yinbolove576的专栏
09-06 813
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 七、IO(Input Output)流          1，IO概述 1)       IO流用来处理的设备之间的数据传输 2)       Java对数据的操作是通过流的方式 3)       Java用于操作流
黑马程序员_07Java图形化界面GUI知识总结
yinbolove576的专栏
09-06 800
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 八、图形化界面GUI 1、GUI概述 GUI（图形用户界面） Graphical UserInterface（图形用户接口）。用图形的方式，来显示计算机操作的界面，这样更方便更直观。 CLI：Command Line
黑马程序员_04Java_API知识总结
yinbolove576的专栏
09-06 708
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 四、API 1，API： ApplicationProgramming Interface，应用程序编程接口，是一些预定义的函数，目的是提供应用程序与开发人员基于某软件或硬件的以访问一组编程的能力，而且无需访问远吗，或理
黑马程序员_02Java面向对象总结
yinbolove576的专栏
09-06 656
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 三：面向对象 1，  面向对象 1.     面向过程 强调过程，执行者 2.     面向对象 强调对象，指挥者 特点： 1)将复杂的事情简单化。 2)面向对象将以前的过程中的执行者，变成了指挥者。 3)面向
ElasticSearch 的 聚合（Aggregations）-javaAPI示例
06-10
好的，以下是一个简单的ElasticSearch聚合的Java API示例： ```java import org.elasticsearch.action.search.SearchResponse; import org.elasticsearch.client.Client; import org.elasticsearch.index.query....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值