一 静态导入

  在导包的过程中我们可以直接导入静态部分,这样某个类的静态成员就可以直接使用了。

在源码中经常会出现静态导入。

静态导入格式:

  import static XXX.YYY;   导入后YYY可直接使用。

Map.Entry的访问,简化后为Entry

import static java.util.Map.Entry;
public class HashMapTest {
public static void main(String[] args) {
//1,创建hashmap集合对象。
Map<Student,String> map = new HashMap<Student,String>(); //取出元素。键值对方式
//Set<Map.Entry<Student, String>> entrySet = map.entrySet();
Set<Entry<Student, String>> entrySet = map.entrySet(); //for (Map.Entry<Student, String> entry : entrySet) {
for (Entry<Student, String> entry : entrySet) {
Student key = entry.getKey();
String value = entry.getValue();
System.out.println(key.toString()+"....."+value);
}
}
}

二 可变参数

  在JDK1.5之后,如果我们定义一个方法需要接受多个参数,并且多个参数类型一致,我们可以对其

简化成如下格式:

  修饰符 返回值类型 方法名(参数类型... 形参名){  }

其实这个书写完全等价与

  修饰符 返回值类型 方法名(参数类型[] 形参名){  }

  只是后面这种定义,在调用时必须传递数组,而前者可以直接传递数据即可。

  jdk1.5以后。出现了简化操作... 用在参数上,称之为可变参数。

  同样是代表数组,但是在调用这个带有可变参数的方法时,不用创建数组(这就是简单之处),直接将

数组中的元素作为实际参数进行传递,其实编译成的class文件,将这些元素先封装到一个数组中,在进

行传递。这些动作都在编译.class文件时,自动完成了。

代码演示:

public class ParamDemo {
public static void main(String[] args) {
int[] arr = {21,89,32};
int sum = add(arr);
System.out.println(sum);
sum = add(21,89,32);//可变参数调用形式
System.out.println(sum); } //JDK1.5之后写法
public static int add(int...arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
} //原始写法
/*
public static int add(int[] arr) {
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
*/
}

  上述add方法在同一个类中,只能存在一个。因为会发生调用的不确定性

  注意:如果在方法书写时,这个方法拥有多参数,参数中包含可变参数,可变参数一定

要写在参数列表的末尾位置。

三  Collections集合工具类

  Collections是集合工具类,用来对集合进行操作。部分方法如下:

public static <T> void sort(List<T> list) // 集合元素排序

//排序前元素list集合元素 [33,11,77,55]
Collections.sort( list );
//排序后元素list集合元素 [11,33,55,77]

public static void shuffle(List<?> list) //  集合元素存储位置打乱

//list集合元素 [11,33,55,77]
Collections.shuffle( list );
//使用shuffle方法后,集合中的元素为[77,33,11,55],每次执行该方法,集合中存储的元素位置都会随机打乱

四 集合嵌套

  集合嵌套并不是一个新的知识点,仅仅是集合内容又是集合,如Collection集合嵌套、Collection

集合与Map集合相互嵌套、Map集合嵌套。

ArrayList嵌套 ArrayList

  ArrayList< ArrayList<String> >

  Collection< ArrayList<Integer> >

Map嵌套 ArrayList

  HashMap<String, ArrayList<Person>>

  ArrayList< HashMap<String, String>>

Map集合嵌套

  HashMap<String, HashMap<String,String>>

  HashMap<String, HashMap<Person,String>>

map 集合嵌套的遍历

package com.oracle.demo02;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set; import com.oracle.demo01.Person; public class Demo04 {
public static void main(String[] args) {
HashMap<String, HashMap<Person,String>> oracle = new
HashMap<String, HashMap<Person,String>>();
//造数据
HashMap<Person, String> java0512 = new HashMap<Person,String>();
java0512.put(new Person("小红",18),"优秀" );
java0512.put(new Person("小白",20),"不及格" );
HashMap<Person, String> java0715 = new HashMap<Person,String>();
java0715.put(new Person("小绿",25),"良好" );
java0715.put(new Person("小黑",23),"及格" );
oracle.put("java0512", java0512);
oracle.put("java0715", java0715);
//keyset 增强for
/*Set<String> bigkeyset = oracle.keySet();
for (String bigkey : bigkeyset) {
HashMap<Person,String> smallhm = oracle.get(bigkey);
Set<Person> smallkeyset = smallhm.keySet();
for (Person smallkey : smallkeyset) {
String smallvalue = smallhm.get(smallkey);
System.out.println(bigkey+"..."+smallkey+"..."+smallvalue);
}
}*/
//Iteratro
/*Set<String> bigkeyset = oracle.keySet();
Iterator<String> bigit = bigkeyset.iterator();
while(bigit.hasNext()){
String bigkey = bigit.next();
HashMap<Person,String> smallhm = oracle.get(bigkey);
Set<Person> smallkeyset = smallhm.keySet();
Iterator<Person> smallit = smallkeyset.iterator();
while (smallit.hasNext()) {
Person smallkey = smallit.next();
System.out.println(bigkey+"..."+smallkey+"..."+smallhm.get(smallkey));
}
}*/
//entry+增强for
/* Set<Map.Entry<String, HashMap<Person,String>>> bighmset = oracle.entrySet();
for (Entry<String, HashMap<Person, String>> bighm : bighmset) {
String bigkey = bighm.getKey();
HashMap<Person,String> smallhm = bighm.getValue();
Set<Map.Entry<Person,String>> smallhmset = smallhm.entrySet();
for (Entry<Person, String> smallhmen : smallhmset) {
Person smallkey = smallhmen.getKey();
String smallvalue = smallhmen.getValue();
System.out.println(bigkey+"..."+smallkey+"..."+smallvalue);
}
}*/
//iterator
/* Set<Map.Entry<String, HashMap<Person,String>>> bighmset = oracle.entrySet();
Iterator<Entry<String, HashMap<Person,String>>> bigit = bighmset.iterator();
while (bigit.hasNext()) {
Entry<String, HashMap<Person,String>> bighmen = bigit.next();
String bigkey = bighmen.getKey();
HashMap<Person,String> smallhm = bighmen.getValue();
Set<Map.Entry<Person,String>> smallset = smallhm.entrySet();
Iterator<Entry<Person,String>> smallit = smallset.iterator();
while (smallit.hasNext()) {
Entry<Person, String> smallen = smallit.next();
Person smallkey = smallen.getKey();
String smallvaule = smallen.getValue();
System.out.println(bigkey+"..."+smallkey+"..."+smallvaule);
}
}*/
//keyset
/*Set<String> bigset = oracle.keySet();
for (String bigkey : bigset) {
HashMap<Person,String> smallhm = oracle.get(bigkey);
Set<Person> smallset = smallhm.keySet();
for (Person smallkey : smallset) {
String smallvaule = smallhm.get(smallkey);
System.out.println(bigkey+" "+smallkey+" "+smallvaule);
}
}*/
/* Set<String> bigset = oracle.keySet();
Iterator<String> bigit = bigset.iterator();
while (bigit.hasNext()) {
String bigkey = bigit.next();
HashMap<Person,String> smallhm = oracle.get(bigkey);
Set<Person> smallset = smallhm.keySet();
Iterator<Person> smallit = smallset.iterator();
while (smallit.hasNext()) {
Person smallkey = smallit.next();
String smallvaule = smallhm.get(smallkey);
System.out.println(bigkey+" "+smallkey+" "+smallvaule);
}
}*/
//entry
/*Set<Entry<String, HashMap<Person,String>>> bigset = oracle.entrySet();
for (Entry<String, HashMap<Person, String>> bigen : bigset) {
String bigkey = bigen.getKey();
HashMap<Person, String> smallhm = bigen.getValue();
Set<Entry<Person, String>> smallset = smallhm.entrySet();
for (Entry<Person, String> smallen : smallset) {
Person smallkey = smallen.getKey();
String smallvaule = smallen.getValue();
System.out.println(bigkey+" "+smallkey+" "+smallvaule);
}
}*/
Set<Entry<String, HashMap<Person,String>>> bigset = oracle.entrySet();
Iterator<Entry<String, HashMap<Person,String>>> bigit = bigset.iterator();
while (bigit.hasNext()) {
Entry<String, HashMap<Person,String>> bigen = bigit.next();
String bigkey = bigen.getKey();
HashMap<Person,String> smallhm = bigen.getValue();
Set<Entry<Person,String>> smallset = smallhm.entrySet();
Iterator<Entry<Person,String>> smallit = smallset.iterator();
while (smallit.hasNext()) {
Entry<Person,String> smallen = smallit.next();
Person smallkey = smallen.getKey();
String smallvaule = smallen.getValue();
System.out.println(bigkey+" "+smallkey+" "+smallvaule);
}
}
}
}

五 集合继承体系的面向对象思想

接口:用来明确所有集合中该具有的功能,相当于在定义集合功能标准;

抽象类:把多个集合中功能实现方式相同的方法,抽取到抽象类实现,具体集合不再遍写,继承使用即可;

具体类:继承抽象类,实现接口,重写所有抽象方法,达到具备指定功能的集合。每个具体集合类,根据自

身的数据存储结构方式,对接口中的功能方法,进行不同方式的实现。

java 静态导入、可变参数、集合嵌套的更多相关文章

  1. Java中的可变参数以及foreach语句

    Java中的可变参数的定义格式如下: 返回值类型  方法名称(类型 ... 参数名称){} foreach语句的格式如下: for ( 数据类型  变量名称 :数据名称){ ... } public ...

  2. Java-Runoob-高级教程-实例-方法:14. Java 实例 – Varargs 可变参数使用

    ylbtech-Java-Runoob-高级教程-实例-方法:14. Java 实例 – Varargs 可变参数使用 1.返回顶部 1. Java 实例 - Varargs 可变参数使用  Java ...

  3. Java静态导入

    Java静态导入 静态导入的语法是: import static ...; 静态导入的好处就是可以简化一些操作,例如System.out.println(…);就可以将其写入一个静态方法 import ...

  4. [集合]java中的 可变参数

    可变的参数类型,也称为不定参数类型.英文缩写是varargus,还原一下就是variable argument type.通过它的名字可以很直接地看出来,这个方法在接收参数的时候,个数是不定的. pu ...

  5. Java学习:可变参数

    可变参数 可变参数:是JDK1.5 之后出现的新特性 使用前提: 当方法的参数列表数据类型已经确定,但是参数的个数不确定,就可以使用可变参数. 使用格式:定义方法时使用 修饰符 返回值类型 方法名(数 ...

  6. 【译】Java中的可变参数

    译文链接 http://www.programcreek.com/2014/01/java-varargs-examples/ 什么是Java可变参数 可变参数是Java 1.5引入的一个特性,它允许 ...

  7. 【Java基础】可变参数

    下面是一个简单的小程序: import java.util.Arrays; class lesson6 { public static void main(String[] args) { ,,,,, ...

  8. java基础40 可变参数、自动装箱和自动拆箱

    一.可变参数 可变参数是jdk1.5新特性 1.1.可变参数的格式 数据类型...变量名 // 数据类型...变量名public static void sum(int...arr){ } 1.2.可 ...

  9. JAVA静态导入(inport static)详解

    在Java 5中,import语句得到了增强,以便提供甚至更加强大的减少击键次数功能,虽然一些人争议说这是以可读性为代价的.这种新的特性成为静态导入. 当你想使用static成员时,可以使用静态导入( ...

随机推荐

  1. 3个月不发工资,拖延转正?2天跳槽软件测试成功,9.5k他不香吗!

    今天聊到的小哥哥很悲催又很神奇,身处武汉的他,正好赶上了疫情,不仅长达3个月没有发工资,拖延转正,还要降薪,三重打击,实名悲催. 不破不立,试用期80%再打8折,怎么跳槽工资都得比这高,果然,仅仅两天 ...

  2. OSCP Learning Notes - Post Exploitation(4)

    Pivoting 1. Edit the virtual network settings of the Vmware. 2. Set the Network Adapter(s) of Kali L ...

  3. 【Python学习笔记二】开始学习啦!如何在IDEA中新建python文件

    1.新建module   2.选择本地安装的python   3.右键新建的module,创建python file就可以开始编程了   4.有时候回出现无法识别python内建函数的问题,就是运行没 ...

  4. 搭建sonarqube分析golang代码

    准备postgres 为什么不使用Mysql呢,因为从7.9就不支持了 docker启动postgres docker run -d \ --name sonar-postgres \ -e POST ...

  5. final总结

    final 1.类 不含任何子类,有父类(太监类):其中方法不能覆盖重写. 2.方法 最终方法,不能被覆盖重写. 3.局部变量 赋值后不能改变,只能赋一次值. 4.成员变量 <1>由于成员 ...

  6. UVA1104 芯片难题 Chips Challenge

    题目链接 题意 网格上放点,有些强制放,有些不能放,有些可以放可以不放.要求: 第 \(i\) 行的点数 = 第 \(i\) 列的点数 每一行每一列的点数不超过总点数的 \(k\) 倍(\(k\) 已 ...

  7. Netty 学习笔记(2) ------ 数据传输载体ByteBuf

    Netty中读写以ByteBuf为载体进行交互 ByteBuf的结构 ByteBuf以readerIndex和writerIndex划分为三块区域,废弃字节,可读字节,可写字节.每次从ByteBuf读 ...

  8. 把若依管理系统部署到Linux

    一.前言 1.非常感谢若依作者为大家提供的非常优质的开源web项目,非常感谢!!! 2.若依官方文档:http://doc.ruoyi.vip/ruoyi/ 3.若依官方链接: 1)若依管理系统官方体 ...

  9. 一周一个中间件-ES搜索引擎

    ---toc: truetitle: 一周一个中间件-ES搜索引擎date: 2019-09-19 18:43:36tags: - 中间件 - 搜索引擎--- ## 前言 > 在众多搜索引擎中, ...

  10. phpcms视频模块实现列表页打开内容页直接播放视频

    摘自phpcms论坛 原链接地址:http://bbs.phpcms.cn/thread-557691-1-1.html 之前下载研究过“化蝶自在飞”开发的视频模型,发现功能不错,但唯一的缺憾是,我想 ...