数组实例：
package org.example.common;
public class ZongJie {
// 数组作为函数参数
public static void printArray(int[] array)
{
System.out.println(array.length);
System.out.println("--------------------111");
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println("--------------------222");
for (int i=0;i<array.length;i++)
{
System.out.println(array[i]);
}
System.out.println("--------------------333");
}
// 数组作为函数返回值
public static int[] calculate(int a,int b,int c)
{
int sum = a+b+c;
int avg = sum/3;
int[] array = {sum,avg};
System.out.println(array[0]);
System.out.println(array[1]);
return array;
}
public static void main(String[] args) {
int[] as = new int[4]; // 数组动态初始化，方式一
as[0] = 1;
as[1] = 2;
as[2] = 3;
as[3] = 4;
int[] ad; //数组动态初始化，方式二
ad = new int[10];
// -------------------------------------------------------------
String[] ab = {"a","b","c","d"}; // 数据静态初始化，指定长度
int[] aw = new int[] {1,2,3,4,5,6,7,8}; // 数据静态初始化，指定长度 --此为上一行模式的省略模式
// -------------------------------------------------------------
printArray(aw); // 函数调用，数组作为参数；
// -------------------------------------------------------------
System.out.println(calculate(1,2,3).length); //函数调用，数组作为返回值；
}
}
==============================================================================================================================
循环实例
package org.example.common.foruse;
public class ForUse {
public static void main(String[] args) {
for(int i=10;i<20;i++)
{
System.out.println(i);
}
System.out.println("---------------------000");
int i = 2;
while (i<10){
System.out.println(i);
i++;
}
System.out.println("---------------------111");
int j=2;
do{
System.out.println(j);
j++;
}while (j<5);
}
}
==============================================================================================================================
对象
package org.example.common;
public class Product {
String name;
int price;
public Product(String name, int price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
@Override
public String toString() {
return "Product{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
==============================================================================================================================
List——arraylist——01
package org.example.common.list;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* java.util.List接口 extends Collection接口
*
* List接口的特点:
* 1.有序的集合,存储元素和取出元素的顺序是一致的(存储123 取出123)
* 2.有索引,包含了一些带索引的方法
* 3.允许存储重复的元素
*
* List接口中带索引的方法(特有)
*
* public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
* public E get(int index):返回集合中指定位置的元素。
* public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
* public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
*
* 注意:
* 操作索引的时候,一定要防止索引越界异常
*
* IndexOutOfBoundsException:索引越界异常,集合会报
* ArrayIndexOutOfBoundsException:数组索引越界异常
* StringIndexOutOfBoundsException:字符串索引越界异常
*
*
*
* LinkedList集合
*
* java.util.LinkedList集合 implements List接口
* ##** LinkedList集合的特点:**
* 1.底层是一个链表结构:查询慢,增删快
* 2.里边包含了大量操作首尾元素的方法
* 注意:使用LinkedList集合特有的方法,不能使用多态
*
* public void addFirst(E e):将指定元素插入此列表的开头。
*
* public void addLast(E e):将指定元素添加到此列表的结尾。
*
* public void push(E e):将元素推入此列表所表示的堆栈。
*
* public E getFirst():返回此列表的第一个元素。
*
* public E getLast():返回此列表的最后一个元素。
*
* public E removeFirst():移除并返回此列表的第一个元素。
*
* public E removeLast():移除并返回此列表的最后一个元素。
*
* public E pop():从此列表所表示的堆栈处弹出一个元素。
*
* public boolean isEmpty()：如果列表不包含元素，则返回true。
*
*/
public class DemoListArrayList
{
public static void main(String[] args) {
//创建一个List集合对象,多态
List<String> list = new ArrayList<>();
//使用add方法往集合中添加元素
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("a");
//打印集合
System.out.println(list); //[a, b, c, d, a] 不是地址，是因为重写了toString
//public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
//在c和d之间添加一个itheima
list.add(3, "itheima"); //[a, b, c, itheima, d, a]
System.out.println(list);
//public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
//移除元素
String removeE = list.remove(2);
System.out.println("被移除的元素:" + removeE); //被移除的元素:c
System.out.println(list); //[a, b, itheima, d, a]
//public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
//把最后一个a,替换为A
String setE = list.set(4, "A");
System.out.println("被替换的元素:" + setE); //被替换的元素:a
System.out.println(list); //[a, b, itheima, d, A]
//List集合遍历有3种方式
//使用普通的for循环
for (int i = 0; i < list.size(); i++) {
//public E get(int index):返回集合中指定位置的元素。
String s = list.get(i);
System.out.println(s);
}
System.out.println("-----------------");
//使用迭代器
Iterator<String> it = list.iterator();
while (it.hasNext())
{
String s = it.next();
System.out.println(s);
}
}
}
==============================================================================================================================
List——arraylist——02
package org.example.common.listuse;
import org.example.common.Product;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListUse{
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
System.out.println(list); // [1, 2, 3, 4, 5]
System.out.println("------------------------");
System.out.println(list.size()); // 5
System.out.println(list.get(0)); // 1
System.out.println(list.get(4)); // 5
System.out.println("-------------------000");
for (int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
/**
* 1
* 2
* 3
* 4
* 5
*/
System.out.println("-----------------111");
List listProduct = new ArrayList<Product>();
Product product001 = new Product("ma001",100);
Product product002 = new Product("ma002",100);
Product product003 = new Product("ma003",100);
Product product004 = new Product("ma004",100);
Product product005 = new Product("ma005",100);
listProduct.add(product001);
listProduct.add(product002);
listProduct.add(product003);
listProduct.add(product004);
listProduct.add(product005);
System.out.println(listProduct.get(0));
System.out.println(listProduct.get(4));
System.out.println(listProduct);
/**
* Product{name='ma001', price=100}
* Product{name='ma005', price=100}
* [Product{name='ma001', price=100}, Product{name='ma002', price=100}, Product{name='ma003', price=100}, Product{name='ma004', price=100}, Product{name='ma005', price=100}]
*
*/
System.out.println("-----------------------222");
Iterator it = listProduct.iterator();
while (it.hasNext()){
Product ww = (Product)it.next();
System.out.println(ww.getName()+" "+ww.getPrice());
}
/**
* ma001 100
* ma002 100
* ma003 100
* ma004 100
* ma005 100
*/
System.out.println("--------------------------------333");
List<Product> as = new ArrayList<Product>();
Product product006 = null;
as.add(product006);
System.out.println(as.size());
System.out.println(as.get(0));
/**
* 1
* null
*
*/
System.out.println("----------------------------------------------------------");
Iterator itt = listProduct.iterator();
while (itt.hasNext()){
System.out.println(itt.next());
}
/**
*
* Product{name='ma001', price=100}
* Product{name='ma002', price=100}
* Product{name='ma003', price=100}
* Product{name='ma004', price=100}
* Product{name='ma005', price=100}
*/
}
}
==============================================================================================================================
Linkedlist——实例001
package org.example.common.list;
import java.util.LinkedList;
/**
* java.util.LinkedList集合 implements List接口
*
* ##** LinkedList集合的特点:**
* 1.底层是一个链表结构:查询慢,增删快
* 2.里边包含了大量操作首尾元素的方法
* 注意:使用LinkedList集合特有的方法,不能使用多态
*
*
*
* public void addFirst(E e):将指定元素插入此列表的开头。
*
* public void addLast(E e):将指定元素添加到此列表的结尾。
*
* public void push(E e):将元素推入此列表所表示的堆栈。
*
* public E getFirst():返回此列表的第一个元素。
*
* public E getLast():返回此列表的最后一个元素。
*
* public E removeFirst():移除并返回此列表的第一个元素。
*
* public E removeLast():移除并返回此列表的最后一个元素。
*
* public E pop():从此列表所表示的堆栈处弹出一个元素。
*
* public boolean isEmpty()：如果列表不包含元素，则返回true。
*/
public class DemoListLinkedList
{
public static void main(String[] args)
{
show03();
System.out.println("--------------------");
show02();
System.out.println("--------------------");
show01();
}
/*
- public E removeFirst():移除并返回此列表的第一个元素。
- public E removeLast():移除并返回此列表的最后一个元素。
- public E pop():从此列表所表示的堆栈处弹出一个元素。此方法相当于 removeFirst
*/
private static void show03()
{
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<>();
//使用add方法往集合中添加元素
linked.add("a");
linked.add("b");
linked.add("c");
System.out.println(linked); //[a, b, c]
//String first = linked.removeFirst();
String first = linked.pop();
System.out.println("被移除的第一个元素:"+first);
String last = linked.removeLast();
System.out.println("被移除的最后一个元素:"+last);
System.out.println(linked);//[b]
}
/*
- public E getFirst():返回此列表的第一个元素。
- public E getLast():返回此列表的最后一个元素。
*/
private static void show02()
{
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<>();
//使用add方法往集合中添加元素
linked.add("a");
linked.add("b");
linked.add("c");
//linked.clear();//清空集合中的元素 在获取集合中的元素会抛出NoSuchElementException
//public boolean isEmpty()：如果列表不包含元素，则返回true。
if(!linked.isEmpty())
{
String first = linked.getFirst();
System.out.println(first);//a
String last = linked.getLast();
System.out.println(last);//c
}
}
/*
- public void addFirst(E e):将指定元素插入此列表的开头。
- public void addLast(E e):将指定元素添加到此列表的结尾。
- public void push(E e):将元素推入此列表所表示的堆栈。此方法等效于 addFirst(E)。
*/
private static void show01()
{
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<>();
//使用add方法往集合中添加元素
linked.add("a");
linked.add("b");
linked.add("c");
System.out.println(linked);//[a, b, c]
//public void addFirst(E e):将指定元素插入此列表的开头。
//linked.addFirst("www");
linked.push("www");
System.out.println(linked);//[www, a, b, c]
//public void addLast(E e):将指定元素添加到此列表的结尾。此方法等效于 add()
linked.addLast("com");
System.out.println(linked);//[www, a, b, c, com]
}
}
==============================================================================================================================
Linkedlist——实例002
package org.example.common;
import java.util.Iterator;
import java.util.LinkedList;
public class ZongJie {
public static void main(String[] args) {
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<>();
//使用add方法往集合中添加元素
linked.add("a");
linked.add("b");
linked.add("c");
System.out.println(linked); //[a, b, c]
System.out.println("----------------------------------111");
Iterator it = linked.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}
System.out.println("----------------------------------222");
//String first = linked.removeFirst();
String first = linked.pop();
System.out.println("被移除的第一个元素:"+first);
System.out.println("----------------------------------333");
String last = linked.removeLast();
System.out.println("被移除的最后一个元素:"+last);
System.out.println("----------------------------------444");
System.out.println(linked);//[b]
System.out.println("----------------------------------555");
}
}
==============================================================================================================================
set集合
HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。
HashSet 允许有 null 值。
HashSet 是无序的，即不会记录插入的顺序。
HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 您必须在多线程访问时显式同步对 HashSet 的并发访问。
HashSet 实现了 Set 接口。
package org.example.common.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
*Set集合的概述
*
* java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。
*
* 与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
*
*
* Set集合有多个子类，这里我们介绍其中的java.util.HashSet、java.util.LinkedHashSet这两个集合。
*
* tips:Set集合取出元素的方式可以采用：迭代器、增强for。
*
*
*
*
*
*
*HashSet集合介绍
*
* java.util.Set接口 extends Collection接口
*
* Set接口的特点:
* 1.不允许存储重复的元素
* 2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
*
* java.util.HashSet集合 implements Set接口
*
* HashSet特点:
* 1.不允许存储重复的元素
* 2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
* 3.是一个无序的集合,存储元素和取出元素的顺序有可能不一致
* 4.底层是一个哈希表结构(查询的速度非常的快)
*
*
*
*/
public class DemoSetHashSet
{
public static void main(String[] args) {
Set<Integer> set = new HashSet<>();
//使用add方法往集合中添加元素
set.add(1);
set.add(3);
set.add(2);
set.add(1);
//使用迭代器遍历set集合
Iterator<Integer> it = set.iterator();
while (it.hasNext())
{
Integer n = it.next();
System.out.println(n); //1,2,3
}
//使用增强for遍历set集合
System.out.println("-----------------");
for (Integer i : set)
{
System.out.println(i);
}
}
}
==============================================================================================================================
package org.example.common;
import java.util.Objects;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Person{" +
"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;
}
}
package org.example.common.set;
import org.example.common.Person;
import java.util.HashSet;
/**
*HashSet存储自定义类型元素
*
* HashSet存储自定义类型元素
*
* set集合必须元素唯一:
*
* 存储的元素(String,Integer,...Student,Person...),必 须重写hashCode方法和equals方法
*
* 要求:
* 同名同年龄的人,视为同一个人,只能存储一次
*
*
*/
public class DemoSetHashSetForOne {
public static void main(String[] args) {
//创建HashSet集合存储Person
HashSet<Person> set = new HashSet<>();
Person p1 = new Person("小美女",18);
Person p2 = new Person("小美女",18);
Person p3 = new Person("小美女",19);
System.out.println(p1.hashCode());//1967205423
System.out.println(p2.hashCode());//42121758
System.out.println(p1==p2);//false
System.out.println(p1.equals(p2));//false
set.add(p1);
set.add(p2);
set.add(p3);
System.out.println(set);
}
}
package org.example.common.set;
import java.util.HashSet;
import java.util.LinkedHashSet;
/**
*
* LinkedHashSet集合
*
* java.util.LinkedHashSet集合 extends HashSet集合
*
* LinkedHashSet集合特点:
* 底层是一个哈希表(数组+链表/红黑树)+链表:多了一条链表(记录元素的存储顺序),保证元素有序
*
*
*
*
*
*
*/
public class DemoSetLinkedHashSet {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("www");
set.add("abc");
set.add("abc");
set.add("itcast");
System.out.println(set); //[abc, www, itcast] 无序,不允许重复
LinkedHashSet<String> linked = new LinkedHashSet<>();
linked.add("www");
linked.add("abc");
linked.add("abc");
linked.add("itcast");
System.out.println(linked); //[www, abc, itcast] 有序,不允许重复
}
}
==============================================================================================================================
map——01
package org.example.common.map;
import java.util.HashMap;
import java.util.Map;
/**
* Map集合的概述
*
* Map集合的特点
* java.util.Map集合
* Map集合的特点:
* 1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)
* 2.Map集合中的元素,key和value的数据类型可以相同,也可以不同
* 3.Map集合中的元素,key是不允许重复的,value是可以重复的
* 4.Map集合中的元素,key和value是一一对应
*
*
*Map常用子类——————————java.util.HashMap集合 implements Map接口
*
*
*HashMap集合的特点:
* 1.HashMap集合底层是哈希表:查询的速度特别的快
* JDK1.8之前:数组+单向链表
* JDK1.8之后:数组+单向链表|红黑树(链表的长度超过8):提高查询的速度
*
* 2.hashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致
*
*
* java.util.LinkedHashMap集合 extends HashMap集合
* LinkedHashMap的特点:
* 1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
* 2.LinkedHashMap集合是一个有序的集合,存储元素和取出元素的顺序是一致的
*
*
*
*
*
*
* Map接口中的常用方法
*
* Map接口中定义了很多方法，常用的如下：
*
* public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
*
* public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
*
* public V get(Object key)根据指定的键，在Map集合中获取对应的值。
*
* boolean containsKey(Object key)判断集合中是否包含指定的键。
*
* public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
*
* public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
*
*/
public class DemoMap
{
private static void show02 ()
{
//创建Map集合对象
Map<String, Integer> map = new HashMap<>();
map.put("赵丽颖", 168);
map.put("杨颖", 165);
map.put("林志玲", 178);
System.out.println(map); //{林志玲=178, 赵丽颖=168, 杨颖=165}
Integer v1 = map.remove("林志玲");
System.out.println("v1:" + v1); //v1:178
System.out.println(map);//{赵丽颖=168, 杨颖=165}
//int v2 = map.remove("林志颖");//自动拆箱 NullPointerException
Integer v2 = map.remove("林志颖");
System.out.println("v2:" + v2); //v2:null
System.out.println(map);//{赵丽颖=168, 杨颖=165}
}
/*
public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
返回值:v
存储键值对的时候,key不重复,返回值V是null
存储键值对的时候,key重复,会使用新的value替换map中重复的value,返回被替换的value值
*/
private static void show01 ()
{
//创建Map集合对象,多态
Map<String, String> map = new HashMap<>();
String v1 = map.put("李晨", "范冰冰1");
System.out.println("v1:" + v1); //v1:null
String v2 = map.put("李晨", "范冰冰2");
System.out.println("v2:" + v2); //v2:范冰冰1
System.out.println(map);//{李晨=范冰冰2}
map.put("冷锋", "龙小云");
map.put("杨过", "小龙女");
map.put("尹志平", "小龙女");
System.out.println(map);//{杨过=小龙女, 尹志平=小龙女, 李晨=范冰冰2, 冷锋=龙小云}
}
public static void main(String[] args)
{
show02();
System.out.println("--------------");
show01();
}
}
{林志玲=178, 赵丽颖=168, 杨颖=165}
v1:178
{赵丽颖=168, 杨颖=165}
v2:null
{赵丽颖=168, 杨颖=165}
--------------
v1:null
v2:范冰冰1
{李晨=范冰冰2}
{杨过=小龙女, 尹志平=小龙女, 李晨=范冰冰2, 冷锋=龙小云}
====================================================================================================================
map——02
package org.example.common;
import java.util.Objects;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Person{" +
"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;
}
}
package org.example.common.map;
import org.example.common.Person;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
*
*HashMap存储自定义类型键值
*Map集合保证key是唯一的:
*作为key的元素,必须重写hashCode方法和equals方法,以保证key唯一
*
*/
public class DemoMapForCustomObject {
public static void main(String[] args) {
show02();
System.out.println("-----------------");
show01();
}
/*
HashMap存储自定义类型键值
key:Person类型
Person类就必须重写hashCode方法和equals方法,以保证key唯一
value:String类型
可以重复
*/
private static void show02() {
//创建HashMap集合
HashMap<Person,String> map = new HashMap<>();
//往集合中添加元素
map.put(new Person("女王",18),"英国");
map.put(new Person("秦始皇",18),"秦国");
map.put(new Person("普京",30),"俄罗斯");
map.put(new Person("女王",18),"毛里求斯");
//使用entrySet和增强for遍历Map集合
Set<Map.Entry<Person, String>> set = map.entrySet();
for (Map.Entry<Person, String> entry : set) {
Person key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"-->"+value);
}
}
/*
HashMap存储自定义类型键值
key:String类型
String类重写hashCode方法和equals方法,可以保证key唯一
value:Person类型
value可以重复(同名同年龄的人视为同一个)
*/
private static void show01() {
//创建HashMap集合
HashMap<String,Person> map = new HashMap<>();
//往集合中添加元素
map.put("北京",new Person("张三",18));
map.put("上海",new Person("李四",19));
map.put("广州",new Person("王五",20));
map.put("北京",new Person("赵六",18));
//使用keySet加增强for遍历Map集合
Set<String> set = map.keySet();
for (String key : set) {
Person value = map.get(key);
System.out.println(key+"-->"+value);
}
}
}
package org.example.common.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
*
*
*Map集合遍历键找值方式
*
* Map集合的第一种遍历方式:通过键找值的方式
*
* Map集合中的方法:
* SetkeySet() 返回此映射中包含的键的 Set 视图。
* 实现步骤:
* 1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
* 2.遍历set集合,获取Map集合中的每一个key
* 3.通过Map集合中的方法get(key),通过key找到value
*
*
*
*
*
*/
public class DemoMapUseKeyFindValueMethod {
public static void main(String[] args)
{
//创建Map集合对象
Map<String,Integer> map = new HashMap<>();
map.put("赵丽颖",168);
map.put("杨颖",165);
map.put("林志玲",178);
//1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
Set<String> set = map.keySet();
//2.遍历set集合,获取Map集合中的每一个key
//使用迭代器遍历Set集合
Iterator<String> it = set.iterator();
while (it.hasNext())
{
String key = it.next();
//3.通过Map集合中的方法get(key),通过key找到value
Integer value = map.get(key);
System.out.println(key+"="+value);
}
System.out.println("-------------------");
//使用增强for遍历Set集合
for(String key : set)
{
//3.通过Map集合中的方法get(key),通过key找到value
Integer value = map.get(key);
System.out.println(key+"="+value);
}
System.out.println("-------------------");
//使用增强for遍历Set集合
for(String key : map.keySet())
{
//3.通过Map集合中的方法get(key),通过key找到value
Integer value = map.get(key);
System.out.println(key+"="+value);
}
}
}
package org.example.common.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
*
* https://www.kancloud.cn/jysxr/yx101/2168759
*Map集合遍历键值对方法
*
* Map集合遍历的第二种方式:使用Entry对象遍历
*
* Map集合中的方法:
* Set> entrySet() 返回此映射中包含的映射关系的 Set 视图。
*
* 实现步骤:
* 1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
* 2.遍历Set集合,获取每一个Entry对象
* 3.使用Entry对象中的方法getKey()和getValue()获取键与值
*
*
*/
public class DemoMapUseKeyFindValueMethod002
{
public static void main(String[] args) {
//创建Map集合对象
Map<String,Integer> map = new HashMap<>();
map.put("赵丽颖",168);
map.put("杨颖",165);
map.put("林志玲",178);
//1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
Set<Map.Entry<String, Integer>> set = map.entrySet();
//2.遍历Set集合,获取每一个Entry对象
//使用迭代器遍历Set集合
Iterator<Map.Entry<String, Integer>> it = set.iterator();
while(it.hasNext()){
Map.Entry<String, Integer> entry = it.next();
//3.使用Entry对象中的方法getKey()和getValue()获取键与值
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"="+value);
}
System.out.println("-----------------------");
for(Map.Entry<String,Integer> entry:set){
//3.使用Entry对象中的方法getKey()和getValue()获取键与值
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"="+value);
}
}
}
