Java上路15-集合工具类

最新推荐文章于 2022-12-12 16:07:32 发布
最新推荐文章于 2022-12-12 16:07:32 发布
阅读量838 收藏 1
点赞数
分类专栏： Java上路 文章标签： arrays calendar collections Runtime system
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Vigiles/article/details/8223887
版权

一. Collections：

       Collections类完全由在collection上进行操作或返回collection的静态方法组成。

1. 排序、查询：

import java.util.*;
 
class CollectionsDemo
{
       public static void main(String[] args)
       {
              sortDemo();
       }
 
       public static void sortDemo()
       {
              List<String> list=new ArrayList<String>();
              list.add("DaTo");
              list.add("Vigiles");
              list.add("YinZi");
              list.add("YinZi");
              list.add("LiEr");
              sop(list);
 
              Collections.sort(list);    //自然排序
              sop(list);
 
              Collections.sort(list, new StringLengthComparator());   //按比较器排序
              sop(list);
 
              sop("最大:"+Collections.max(list));   //最大。根据元素的自然顺序
              sop("最长:"+Collections.max(list, new StringLengthComparator()));  //按比较器选取最大
 
              //搜索。binarySearch使用二分搜索法搜索指定列表，用于有序的集合
              sop("YinZi索引:"+Collections.binarySearch(list,"YinZi"));
              sop("Gaog索引:"+Collections.binarySearch(list,"Gaog"));
              sop("XinZai索引:"+Collections.binarySearch(list,"XinZai"));
              //binarySearch原理
              int index=halfSearch(list,"cc");
       }
 
       public static int halfSearch(List<String> list, String key)
       {
              int max, min, mid;
              max = list.size()-1;
              min = 0;
              while (min<=max)
              {
                     mid=(max+min)>>1;
                     String str=list.get(mid);
                     int num=str.compareTo(key);
                     if (num>0)
                     {
                            max=mid-1;
                     }
                     else if (num<0)
                     {
                            min=mid+1;
                     }
                     else
                     {
                            return mid;
                     }
              }
              return -min-1;
       }
 
       public static void sop(Object obj)
       {
              System.out.println(obj);
       }
}
 
class StringLengthComparator implements Comparator<String>
{
       public int compare(String s1, String s2)
       {
              if (s1.length()>s2.length())
              {
                     return 1;
              }
              else if(s1.length()<s2.length())
              {
                     return -1;
              }
              else
              {
                     return s1.compareTo(s2);
              }
       }
}

   

2. 逆转排序：

import java.util.*;
 
class CollectionsDemo
{
       public static void main(String[] args)
       {
              sortDemo();
       }
 
       public static void sortDemo()
       {
              //TreeSet<String> list=new TreeSet<String>();
              //TreeSet<String> list=new TreeSet<String>(Collections.reverseOrder());
              //TreeSet<String> list=new TreeSet<String>(new MyComparator());
              TreeSet<String> list=new TreeSet<String>(Collections.reverseOrder(new MyComparator()));
              list.add("DaTo");
              list.add("Vigiles");
              list.add("YinZi");
              list.add("LinErr");
 
              for(Iterator it=list.iterator();it.hasNext();)
              {
                     System.out.println(it.next());
              }
       }
}
 
//长度比较器
class MyComparator implements Comparator<String>
{
       public int compare(String s1, String s2)
       {
              if (s1.length()>s2.length())
              {
                     return 1;
              }
              else if(s1.length()<s2.length())
              {
                     return -1;
              }
              else
              {
                     return s1.compareTo(s2);
              }
       }
}

 

二. Arrays：

       此类包含用来操作数组（比如排序和搜索）的各种方法。

1. 数组变集合：

import java.util.*;
 
class ArraysDemo
{
       public static void main(String[] args)
       {
              String[] arr={"book","foot", "desk", "paper", "bag"};
              List<String>list=Arrays.asList(arr);
              //将数组变成集合，不可以使用集合的增删方法，因为长度固定。否则发生UnsuppportedOperationException异常
 
              sop(list);
 
              int[] num={34, 52, 13, 33};
              List<int[]>ln=Arrays.asList(num);
              sop(ln);
 
              Integer[] nums={23, 54, 35, 65,6};
              List<Integer>li=Arrays.asList(nums);
              sop(li);
       }
 
       public static void sop(Object obj)
       {
              System.out.println("\n"+obj);
       }
}


2. 集合变数组：

import java.util.*;
 
class ArraysDemo
{
       public static void main(String[] args)
       {
              ArrayList<String> al=new ArrayList<String>();
              al.add("desk");
              al.add("book");
              al.add("foot");
 
              /*
              高级for循环遍历集合，只能获取元素，不能进行操作。
              迭代器除了遍历，还可以remove，如果使用ListIterator，还可以在遍历增删改查。
              高级for有局限性：必须有被遍历的目标。遍历数组建议使用传统for。
              */
              for (String s:al)
              {
                     sop(s);
              }
 
              int[] num={85,3,14,2,96};
              for (int i:num)
              {
                     sop(i);
              }
             
              /*
              如果指定类型的数组长度小于集合的size，则该方法自动创建一个长度为size的数组
              如果指定类型的数组长度大于集合的size，会使用传递进来的数组
              */
              String[] arr=al.toArray(new String[al.size()]);
              sop(Arrays.toString(arr));
       }
 
       public static void sop(Object obj)
       {
              System.out.println("\n"+obj);
       }
}


三. 附加：

       JDK1.5后为了简化代码出现了多个新特性。

/*
1.静态导入：
       当类名重名时，须要指定具体的包名；
       当方法重名时，需要指定所属的对象或类名。
2.可变参数：
       是数组作为参数的简写形式；
       只能放在参数列表的最后。
*/
import staticjava.lang.System.*;
import java.util.*;
import staticjava.util.Arrays.*;
 
class NewJdk //extends Object
{
       public static void main(String[] args)
       {
              int[] arr={5,9,3,7,2};
              //使用静态方法。省略了Arrays.
              sort(arr);
              int index=binarySearch(arr, 9);
              //使用静态导入的方法。省略了System.
              out.println("排序后9的索引："+index);
              //因为NewJdk默认继承Object，有了重名的toString方法，所以要指定
              out.println(Arrays.toString(arr));
 
              //arguments(1,5,5,5,6,9);
              arguments("variable","arguments",5,6,9);
       }
 
       //可变参数。放在参数列表最后
       //public static void arguments(int...nums)
       public static void arguments(String s1,String s2, int... nums)
       {
              out.println(s1+" "+s2);
              for (int i=0; i<nums.length;i++)
              {
                     out.print(nums[i]);
              }
       }
}

   

四. 其它常用类：

1.System：

import java.util.*;
 
class CommonClass
{
       public static void main(String[] args)
       {
              //自定义系统信息
              System.setProperty("MyJava","Vigiles");
 
              //获取指定系统信息
              String vl=System.getProperty("os.name");
              System.out.println("vl="+vl);
 
              //Properties是Hashtable的子类
              Properties prop=System.getProperties();
              //System.out.println(prop);
 
              //通过map方法取出prop集合的所有元素
              for (Object obj:prop.keySet())
              {
                     Stringvalue=(String)prop.get(obj);
                     System.out.println(obj+"::"+value);
              }
       }
}


2.Runtime:

       这个类没有构造函数，应用程序不能创建自己的 Runtime 类实例。但有getRuntime()返回与当前 Java 应用程序相关的运行时对象。

class CommonClass
{
       public static void main(String[] args) throws Exception
       {
              Runtime run=Runtime.getRuntime();
 
              //打开记事本，因为其在环境变量中有设置，可以省略全路径
              //run.exec("notepad");
 
              //创建一个进程
              //Process p=run.exec("notepad");
 
              //用记事本打开java文件
              Process p=run.exec("notepadCommonClass.java");
 
              Thread.sleep(1000);    //停留一秒
              //杀死进程
              p.destroy();
       }
}


3.Date：

       类 Date 表示特定的瞬间，精确到毫秒。

import java.util.Date;
import java.text.SimpleDateFormat;
 
class CommonClass
{
       public static void main(String[] args)throws Exception
       {
              Date date=new Date();
              System.out.println(date);
 
              //将模式封装到SimpleDateFormat对象
              SimpleDateFormat sdf=newSimpleDateFormat("yyyy年MM月dd日 E ahh:mm:ss");
              //指定Date对象
              String time=sdf.format(date);
              System.out.println("Now:"+time);
       }
}


4.Calendar：

       为特定瞬间与日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法。

import java.util.Calendar;
 
class CommonClass
{
       public static void main(String[] args)throws Exception
       {
              Calendar c=Calendar.getInstance();
              //返回给定日历字段的值
              System.out.println(c.get(Calendar.YEAR)+"年"+
                                                 (c.get(Calendar.MONTH)+1)+"月"+  //从0开始
                                                 c.get(Calendar.DAY_OF_MONTH)+"日");
 
              //将给定的日历字段设置为给定值
              c.set(2012, 4, 6);
              System.out.println("\n"+c);
 
              //根据日历的规则，为给定的日历字段添加或减去指定的时间量
              c.add(Calendar.YEAR, 2);
              System.out.println("\n"+c);
 
              c.add(Calendar.MONTH, -32);
              System.out.println("\n"+c);
       }
}


5.Math：

       执行基本数学运算的方法。

import java.util.Random;
 
class CommonClass
{
       public static void main(String[] args)throws Exception
       {
              //ceil返回大于参数值的最小整数值
              double d1=Math.ceil(12.34);
              System.out.println("double:"+d1);
 
              //ceil返回小于参数值的最大整数值
              double d2=Math.floor(12.34);
              System.out.println("floor:"+d2);
 
              //四舍五入
              double d3=Math.round(12.34);
              System.out.println("round:"+d3);
 
              //前者的后者次方
              double d4=Math.pow(2, 3);
              System.out.println("pow:"+d4);
 
              //随机数
              double d5=Math.random()*10;
              System.out.println("random:"+d5);
 
              //使用Random类生成随机数
              Random r=new Random();
              for (int i=0; i<5; i++)
              {
                     int d=r.nextInt(10)+1;
                     System.out.print(d);
              }
       }
}



vigiles
关注
专栏目录
【探索集合的“秘密“】集合的体系架构了解
生活很苦，但学习还得继续
08-29 731
容器集合集合概述Collection集合Collection子类接口：List集合List实现类：ArrayList集合List实现类：LinkedList集合ArrayList、LinkedList和Vector三者的异同Collection子类接口：Set集合Map集合 集合概述   最基本两个容器：变量、数组（变量是最小的数组） 集合：可以存储多个数据（对象）且长度可变的容器     集合的体系结构如下图：（这张图很清晰地把整个结构列出来了，建议收藏）     注意：Collection 和 Map
Java包---Java类的组织方式
qq_63691275的博客
09-06 594
包🤔学包前的思考简单介绍包的概念包的作用包的创建🤖包的引入简单介绍Javase API的主要包 🤔学包前的思考 想想在大型的项目中，肯定不是几个类就可以完成的，几千个类甚至上万个类都是有可能的，而且各个类名还不能相同，那混在一起会不会太复杂了点? Java里面提供了一个可以有效组织类的结构-----包。 标准的Java类库就是由包进行组织在一起的。比如我们常用的java.util包就是其中的一个，里面有很多我们常用的类：Scanner,Date,Arrays…等等。 简单介绍包的概念 包是一组相关的类和接口
学习集合工具类CollectionUtils——List对象案例
李长渊的博客
10-20 640
学习集合工具类CollectionUtils——List对象案例
java代码简洁-mapstruct
weixin_43994244的博客
08-04 1863
对象映射工具类
新手上路 -- 02
free_puppet的博客
07-20 143
java编程基础大杂烩第二期
java开发手册-阿里巴巴2020最新版
zw764987243的博客
03-10 2400
前言 《Java 开发手册》是阿里巴巴集团技术团队的集体智慧结晶和经验总结，经历了多次大规模一 线实战的检验及不断完善，公开到业界后，众多社区开发者踊跃参与，共同打磨完善，系统化地整理 成册，当前的版本是嵩山版。现代软件行业的高速发展对开发者的综合素质要求越来越高，因为不仅 是编程知识点，其它维度的知识点也会影响到软件的最终交付质量。比如：五花八门的错误码人为地 增加排查问题的难度；数据库的表结构和索引设计缺陷带来的系统架构缺陷或性能风险；工程结构混 乱导致后续项目维护艰难；没有鉴权的漏洞代码易被黑客攻击等
集合框架|Java集合框架基本使用
gork_mc的博客
12-10 792
大家好，我是程序猿小马，沪漂一族！ 写文章就是对于平时的总结以及大家共同学习进步，早日码出各自的梦想???? 坐标：飞机上的上海 文章目录每日小结 每日小结 以上就是小马今天要发的内容，欢迎大家互相学习，共同进步，也可以在评论区互动哦！???? ...
阿里巴巴Java开发手册（部分）-黄山
最新发布
weixin_42704604的博客
12-12 1015
开发手册
Java课程作业-【接口】
Theseus_sky的博客
12-01 453
Java课程作业-【接口】 一.抽象类和方法 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 抽象类和普通类的主要有三点区别： 1）抽象方法必须为 public 或者 protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），默认情况下默认为 public。 2）抽象类不能用来创建对象； 3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子
Java新手上路Flash教程
09-28
Java集合框架是组织和管理数据的重要工具，包括List（如ArrayList和LinkedList）、Set（如HashSet和TreeSet）和Map（如HashMap和TreeMap）接口，以及实现这些接口的类。 最后，Java还提供了大量的API（应用程序接口...
java 8（二）--函数式数据处理Stream
w1992wishes的博客
07-11 1584
一、前言 有一个池塘，池塘里面有各种各样的鱼虾，假如我想找到所有大于2斤小于3斤的草鱼的名字（假如鱼有名字）。 这个需求很简单，映射到数据库中可以这样查询： SELECT name FROM tbl_fishes WHERE kind = 'grass carp' AND weight 2 这条SQL语句简单明了，剩下的就交给数据库搞定了，那用java如何实现呢？
Java上路04-流程控制语句
Vigiles的编程基础
11-14 1533
一．条件判断语句： 1. if-else，如果，否则。当if的条件成立时，执行if语句块，忽略else语句块， if (条件) {       执行语句1; } else {       执行语句2; } 例子：   2. if-elseif-else，如果，或者如果，否则当第一个if不成立时，会判断紧跟着的else if语句，如果还不成立，执行else if(
Java上路09-多线程
Vigiles的编程基础
11-19 1350
记得九几年小学课本里有一篇华罗庚的文章写的是统筹学，里面的例子大概是这么说的：我们想喝茶，第一种办法，洗刷茶壶，放上茶叶，烧水，等水开了泡茶；第二种办法，烧水，等待水开的时间里洗刷茶壶，放上茶叶，然后水开了泡茶。        生活中的统筹学也就是编程思想中的算法。在此之前我们写的所有程序都可以说是单线程的。因为都是按部就班的干了一样再干另一样。而多线程达到了事半功倍的效果，一个时刻可以进行多个
Java上路06-面向对象
Vigiles的编程基础
11-15 1151
面向对象（Object Oriented Programming，OOP）是一种思想，Java可以通过这种思想设计程序。最笨的理解就是让别人去干活，自己做管理。 一. 类： class Human { public static void main(String[] args) { System.out.println("HelloWorld!我是
Java上路08-包间互访
Vigiles的编程基础
11-17 1130
当类文件很多时，我们按类的功能划分，放到不同的文件夹里。此时类之间的互相调用涉及到包互访的问题。包，就是文件夹。比如我在C盘根目录有个带主函数的Test文件，一个External文件，一个internal文件夹，在文件夹里有个Internal文件。我要从Test中调用External，在External中调用Internal。如下， Test.java文件： class Test {
Java上路07-异常处理
Vigiles的编程基础
11-16 1130
当运行时发生的错误就是异常，而不是编译时发生的语法错误。比如下面： class Computer { void count(int i, int j) { System.out.println("两个数的商是：" + i / j); } } class Exceptions { public static
Java上路20-GUI
Vigiles的编程基础
12-04 1056
GraphicalUser Interface：图形用户接口。AWT：抽象窗口接口，调用系统方法实现；Swing：图形界面组件系统，Java自身实现。 一. AWT的继承关系：   二. 常用布局管理器： FlowLayout（流布局） 从左到右的顺序排列，单个组件默认居中。Panel默认此布局 BorderLayout（边界布局） 东西南北中，当不指定方位时，默认最大化填充
Java上路10-线程通信
Vigiles的编程基础
11-20 906
需求：超市的销售部和采购部同时对仓库进行使用，库存达到100，销售部就卖货，库存小于1000就必须进货。开始运营超市。 代码： class Stock //库存 { public int count=0; //库存数量 } class Procure implements Runnable //采购 { private Stock sk;
Java API深度解析：集合、工具类与Lambda
"Java常用API使用方法的详细指南，涵盖了集合、工具类、Lambda表达式和函数式接口的解析，适合深入理解Java API并应用于算法题目。" 在Java编程中，掌握API的使用是至关重要的，它能帮助我们高效地构建程序。本资源...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值