Map两种遍历方式与TreeSet两种排序依据

集合：可以存储不同类型的多个对象，随着存储对象的个数的增加而自动扩大容量

 

体系结构:

Collection<E>

  |----List:存入的对象是有序的，且可以重复

          ArrayList:底层使用的数据结构是数组，线程不安全的，查找速度快，增删速度慢

          Vector:底层使用的数据结构是数组，线程安全的，查找速度快，增删速度慢

          LinkedList:底层使用的数据结构是链表，线程不安全的，查找速度慢，增删速度快

 

  |----Set:存入的对象是无序的，且不可以重复

          HashSet:底层使用的数据结构是哈希表，线程不安全的

                  保证对象唯一的原理：

                  先判断hashCode()值，如果都不同就直接加入集合，如果哈希值相同了

                  在调用equals()方法，如果equals()方法返回值为true,则认为集合中存在该对象，不加入集合

 

           TreeSet:底层使用的数据结构是二叉树，线程不安全的

                  会对存入集合的对象进行排序

                  保证集合中对象唯一的方式：依据compareTo()或compare()的返回值是否为0

                   排序方式一：让存入集合中的对象具备可比较性

                                让存入集合中的对象所属的类实现Comparable<T>接口中的intcompareTo(T t) 方法

                   排序方式二:让集合具备排序功能

                                定义一个比较器，实现Comparator<T>接口中的int compare(T t1,T t2)方法

                                把比较器对象作为参数传递给TreeSet<E>集合的构造方法

 

                   当集合中的对象具备可比较性，且存在比较器时，比较器优先被使用

 

泛型：<引用数据类型>

       把运行时期的问题转移到了编译时期

       不用再强制类型转换

 

     classDemo<T>

     {

          publicvoid show(T t)

          { }

 

          //自己使用泛型的方法

          public<E> void fun(E e)

          {

          }

 

          //静态方法只能自己使用泛型

          publicstatic <W> void func(W w)

          {}

      }

 

    //泛型定义在接口上

    interfaceinter<T>

    { }

 

    通配符：?

    泛型限定：?extends E  和? super E

 

 

Map<K,V>:一个单独的接口，存储的是键值对，键不可以重复,无序的

 

        HashMap:保证键唯一的原理和HashSet一样，hashCode(),equals()

 

        TreeMap:TreeMap是根据键来排序的,保证键唯一的原理和TreeSet相同,依据

               compareTo()或compare()的返回值是否为0，为0就认为是重复键

 

         Map的迭代方式有两种：

         第一种:

                Set<K> keys  =map.keySet();

                Iterator<K> ite = keys.iterator();

                while(ite.hasNext())

                {

                    K key = ite.next();

                   V value = map.get(key);

                   System.out.println(key+","+value);

                }

         第二种:

               Set<Map.Entry<K,V>> entry = map.entrySet();

               Iterator<Map.Entry<K,V>> ite = entry.iterator();

               while(ite.hasNext())

               {

                  Map.Entry<K,V> en = ite.next();

                  K key = en.getKey();

                  V value = en.getValue();

                  System.out.println(key+","+value);

               }

 

 

工具类：Arrays

       Collections

举例说明：

/*

Collection

List:存储的对象是有序的(取出的顺序和存储的顺序是一致的)，对象是可以重复的

--ArrayList:底层使用的数据结构是数组,查找速度快，增删速度慢 线程不同步的

--LinkedList：底层使用的数据结构是链表，查找速度慢，增删速度快  线程不同步的

--Vector:底层使用的数据结构是数组，线程同步的

Set:存储的对象是无序的(取出的顺序和存储的顺序是不一致的)，对象不可以重复

*/

import java.util.*;
class  Demo1
{
	public static void main(String[] args)
	{
		ArrayList  list = new ArrayList();

		list.add("java01");
		list.add("java02");
		list.add("java03");
		list.add("java03");
		list.add("java02");
		Iterator ite = list.iterator();
		while(ite.hasNext())
		{
			sop(ite.next());
		}

		ArrayList list2 = quChu(list);
		sop(list2);
	}
	//去除集合中的重复元素
	public static ArrayList quChu(ArrayList list)
	{
		ArrayList list2 = new ArrayList();
		for(int i=0;i<list.size();i++)
		{
			Object obj = list.get(i);
			if(!list2.contains(obj))//依据什么来判断是否包含这个对象？boolean equals(Object obj)
			{
			   list2.add(obj);
			}
		}
		return list2;
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

    /*TreeSet:保证集合中对象唯一的方式：依据compareTo()或compare()的返回值是否为0

排序方式一：让存入集合中的对象具备可比较性

                                让存入集合中的对象所属的类实现Comparable<T>接口中的intcompareTo(T t) 方法

                   排序方式二:让集合具备排序功能

                                定义一个比较器，实现Comparator<T>接口中的int compare(T t1,T t2)方法

                                把比较器对象作为参数传递给TreeSet<E>集合的构造方法

 

                   当集合中的对象具备可比较性，且存在比较器时，比较器优先被使用*/

举例说明：

package com.demo.day07;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class Demo8 {
	public static void main(String[] arg)
	{
		ComparaByName comparaByName=new ComparaByName();
		TreeSet ts=new TreeSet(comparaByName);
//		ts.add("sa");
//		ts.add("assa");
//		ts.add("esa");
//		ts.add("fsa");
		ts.add(new People("zs",22));
		ts.add(new People("ls",28));
		ts.add(new People("wm",22));
		ts.add(new People("tt",23));
		Iterator ite=ts.iterator();
		while(ite.hasNext())
		{
			sop(ite.next());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
@SuppressWarnings("rawtypes")
class ComparaByName implements Comparator//<span style="font-weight: bold;">排序方式二</span>
{

	@Override
	public int compare(Object arg0, Object arg1) {
		if(!(arg0 instanceof People))
			throw new ClassCastException("类型不对");
		if(!(arg1 instanceof People))
			throw new ClassCastException("类型不对");
		People per1=(People)arg0;
		People per2=(People)arg1;
		int num=per1.getName().compareTo(per2.getName());
		return num==0?per1.getAge()-per2.getAge():num;
	}

}
class People implements Comparable//<span style="font-weight: bold;">排序方式一</span>
{
	private String name;
	private int age;

	@Override
	public int compareTo(Object obj) {
		if(!(obj instanceof People))
			throw new ClassCastException("类型不对");
		People per=(People)obj;
		int num=this.age-per.age;
		return num==0?this.name.compareTo(per.name):num;
	}
	public People() {
		super();
		// TODO Auto-generated constructor stub
	}

	public People(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "People [name=" + name + ", age=" + age + "]";
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

}

时间： 2024-12-25 20:46:00

Map两种遍历方式与TreeSet两种排序依据的相关文章

重温数据结构：二叉树的常见方法及三种遍历方式 Java 实现

读完本文你将了解到: 什么是二叉树 Binary Tree 两种特殊的二叉树 满二叉树 完全二叉树 满二叉树 和 完全二叉树 的对比图 二叉树的实现 用 递归节点实现法左右链表示法 表示一个二叉树节点 用 数组下标表示法 表示一个节点 二叉树的主要方法 二叉树的创建 二叉树的添加元素 二叉树的删除元素 二叉树的清空 获得二叉树的高度 获得二叉树的节点数 获得某个节点的父亲节点 二叉树的遍历 先序遍历 中序遍历 后序遍历 遍历小结 总结 树的分类有很多种,但基本都是 二叉树 的衍生,今天来学习下二

Map的两种遍历方式

********************************************************************************* *****************************Map两种遍历方式******************************* ********************************************************************************* 1 package ccms;

List集合中两种遍历方式

遍历List集合中的元素的方法有两种: 第一种:利用迭代器遍历 代码1: // 迭代器 Iterator it=list.iterator(); while(it.hasNext()) { System.out.println(it.next()); } 或者代码2: for(Iterator it=list.iterator();it.hasNext();) { System.out.println(it.next()); }// 与while循环相比优点:对象it在循环结束后,变为垃圾,自动

Map集合的几种遍历方式

Map<String ,String> map=new HashMap<String,String>(); map.put("1","value1"); map.put("2","value2"); map.put("3","value3"); //第一种遍历方式: for(String key:map.keySet()){ String key=key; Str

HashMap概述及其三种遍历方式

一.HashMap概述: 1.HashMap是一个散列表,它存储的是键值对(key-value)映射: 2.HashMap继承AbstractMap,实现了Map,Cloneable,Serializable接口: 3.HashMap的实现不是同步的,线程不安全,但是效率高: 4.HashMap允许null键和null值,是基于哈希表的Map接口实现: 5.哈希表的作用是用来保证键的唯一性: 6.HashMap的实例有两个参数影响其性能:初试容量和加载因子,当哈希表中的条目数超出加载因子与当前容

二叉树总结—建树和4种遍历方式（递归&amp;&amp;非递归）

今天总结一下二叉树,要考离散了,求不挂!二叉树最重要的就是 建立.4种遍历方式,简单应用,如何判断两颗二叉树是否相似 二叉树分为 :1.完全二叉树  2.满二叉树 结构性质: 1).满二叉树 高度为h ,节点数则为 2^h - 1,且叶子节点全在最下层,且叶子节点数为2^(n-1)个{n代表二叉树层数,也叫深度} 2).n个节点的 完全二叉树 深度为 int(log2n)(以2为底n的对数)+ 1: 3).非空二叉树 叶子节点个数==双分支节点数+1 4).非空二叉树 某节点编号 n  若有左孩

js数组的4种遍历方式

1 <!DOCTYPE html> 2 <html> 3 <head> 4 <meta charset="utf-8"/> 5 <title>数组的遍历方式</title> 6 <script type="text/javascript"> 7 var arr = [11, 22, 33, 55]; 8 //普通的循环遍历方式 9 function first() { 10 11 f

js中数字的4种遍历方式

<!DOCTYPE html> <html> <head> <meta charset="utf-8"/> <title>数组的遍历方式</title> <script type="text/javascript"> var arr = [11,22,33,55]; //普通的循环遍历方式 function first(){ for(var i= 0;i<arr.length;

有关不同实现类的List的三种遍历方式的探讨

我们知道,List的类型有ArrayList和LinkedList两种,而曾经的Vector已经被废弃. 而作为最常用的操作之一,List的顺序遍历也有三种方式:借助角标的传统遍历.使用内置迭代器和显式迭代器. 下面,将首先给出两种种不同类型实现的实验结果,之后,将会通过分析JAVA中List的各种实现,来探讨造成实验结果的原因. 1.随机数据的生成 package temp; import java.io.*; import java.util.Random; public class Dat