黑马程序员——Java基础--集合框架工具类:Collections、Arrays、其他对象

最新推荐文章于 2022-05-13 15:25:48 发布
最新推荐文章于 2022-05-13 15:25:48 发布
阅读量771 收藏 2
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huailxz/article/details/41441267
版权

------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------

第一讲 Collections

一、简述

     Collections：它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。大部分方法是用于对List集合进行操作的，如比较，二分查找，随机排序等。

二、常见操作

  1. 查找：
    • T max(Collection<? extends T> coll)  根据集合的自然顺序，获取coll集合中的最大元素。
    • T max(Collection<? extends T> coll,Comparator<? super T> comp)  根据指定比较器comp的顺序，获取coll集合中的最大元素
    • T min(Collection<? extends T> coll)  根据元素的自然顺序 返回给定 collection 的最小元素。
    • T min(Collection<? extends T> coll, Comparator<? super T> comp)  根据指定比较器产生的顺序，返回给定 collection 的最小元素。          
    • int intbinarySearch(Lsit<? extends Comparable<? super T>> list,Tkey)   二分法搜索list集合中的指定对象。
    • int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)  使用二分搜索法搜索指定列表，以获得指定对象。 
    • int indexOfSubList(List<?> source, List<?> target)   
      • 返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
    • int lastIndexOfSubList(List<?> source, List<?> target)  
      • 返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。  
  2. 替换：
    • void fill(List<? super T> list, T obj)    将list集合中的全部元素替换成指定对象obj。
    • boolean replaceAll(List<T> lsit,T oldVal,T newVal)   用newVal替换集合中的oldVal值。
    • void swap(Listlist,int i,int j)   在指定列表的指定位置处交换元素。
  3. 排序：
    • void shuffle(List<?> list)   使用默认随机源对list集合中的元素进行随机排序。
    • void sort(Lsit<T> list)    根据自然顺序对list集合中的元素进行排序。
    • void sort(List<T> lsit,Comparator<? super T> c)    根据指定比较器c的排序方式对list集合进行排序。
  4. 反转：
    • reverse(List<?> list)    反转list集合中元素的顺序
    • Comparator reverseOrder()   返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序。
    • ComparatorreverseOrder(Comparator<T> cmp)   返回一个比较器，强行逆转了指定比较器的顺序。
  5. 将非同步集合转成同步集合的方法：Collections中的  XXX synchronizedXXX(XXX);
    • List<T>synchronizedList(List<T> list)   返回支持的同步（线程安全的）List集合。
    • Map<K,V>synchronizedList(Map<K,V> m)   返回支持的同步（线程安全的）Map集合。

三、Collection和Collections的区别

  • Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
  • Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。

练习：

class  CollectionsDemo
{
	public static void main(String[] args) 
	{
		
	}
	//初始化
	public static void init()
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
	}
	//折半查找
	public static void binarySearchDemo()
	{
		init();
		//按自然顺序查找
		//int index = Collections.binarySearch(list,"aaaa");
		//按比较器比较后的顺序查找
		int index = Collections.binarySearch(list,"aaaa",new StrLenComparator());
		sop("index="+index);
	}
	//获取最大值
	public static void maxDemo()
	{
		init()
		Collections.sort(list);
		sop(list);
		String max = Collections.max(list/*,new StrLenComparator()*/);
		sop("max="+max);
	}
	//将集合按升序排序
	public static void sortDemo()
	{
		init();
		sop(list);

		//Collections.sort(list);
		Collections.sort(list,new StrLenComparator());
		//将指定位置元素互换
		//Collections.swap(list,1,2);
		sop(list);
		
	}
	//随机换位
	public static void shuffleDemo()
	{
		init();
		sop(list);
		Collections.shuffle(list);
		sop(list);
	}
	//集合反转,不传比较器按自然顺序反转，传比较器按比较器比较结果反转
	public static void orderDemo()
	{
		TreeSet<String> ts = new TreeSet<String>(/*Collections.reverseOrder(new StrLenComparator())*/);

		ts.add("abcde");
		ts.add("aaa");
		ts.add("k");
		ts.add("cc");

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
	//元素替换
	public static void replaceAllDemo()
	{
		init();
		sop(list);
		Collections.replaceAll(list,"aaa","pp");
		sop(list);
		Collections.reverse(list);
		sop(list);
	}

	//将list集合中部分元素替换成指定元素。
	public static void fillDemo()
	{
		init();
		sop(list);
		Collections.fill(list,"pp");
		sop(list);
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
//定义比较器，让集合自身具备比较性。
class StrComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		/*
		int num = s1.compareTo(s2);
		if(num>0)
			return -1;
		if( num<0)
			return 1;
		return num;
		*/
		return s2.compareTo(s1);
	}
}
//定义比较器，按照长度比较
class StrLenComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()<s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}
第二讲 Arrays

一、简述

        Arrays是用于操作数组的工具类。里边的方法也全是静态的。不需要创建对象。把数组变成List集合的好处：可以使用集合的思想和方法来操作数组中的元素。如：isEmpty、 set、contains、get，indexOf，subList等方法。

二、常见方法

  • Lsit<T>  asList(T... a)  将数组转换为集合。
  • binarySearch()：二分查找。
  • String toString()  可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式。
  • 注意：
    • 数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如add、remove、clear。（会报不支持操作异常UnsupportedOperationException）；
    • 如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。
    • 如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
  • 特点：
    • 可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数。
    • 可以对指定元素的范围，并可根据指定比较器进行相应的操作。
    • sort(T[]a,Comparator<? super T> c)  排序。
    •  fill(int[]a,int from,int to)  替换。

练习：

import java.util.*;
class  ArraysDemo
{
	public static void main(String[] args) 
	{
		int[] numbs = {2,4,5};
		//将int型数组转换成指定数组的字符串表现形式
		sop(Arrays.toString(numbs));

		String[] arr = {"abc","cc","kkkk"};
		//将数组转换成集合
		List<String> list = Arrays.asList(arr);
		sop("contains:"+list.contains("cc"));
		//list.add("qq");//UnsupportedOperationException,
		//int[] nums = {2,4,5};
		Integer[] nums = {2,4,5};
		List<Integer> li = Arrays.asList(nums);

		/*
		如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
		如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
		*/
		sop(li);
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

三、将集合转换成数组

  • 方法：
    • Collection接口中的方法： <T> T[] toArray(T[] a)   将集合变为指定类型的数组。
  • 好处：
    • 限定了对集合中的元素进行增删操作，只要获取这些元素即可。
  • 指定类型的数组到底要定义多长呢？
    • 如果给toArray传递的指定类型的数据长度小于了集合的size，那么toArray方法，会自定再创建一个该类型的数据，长度为集合的size。
    • 如果传递的指定的类型的数组的长度大于了集合的size，那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。
    • 所以，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。

import java.util.*;
class  CollectionToArray
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();

		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		
		String[] arr = al.toArray(new String[al.size()]);
		System.out.println(Arrays.toString(arr));
	}
}

第三讲 扩展知识—JDK1.5部分新特性
简述

        Collection在jdk1.5以后，有了一个父接口Iterable，这个接口的出现的将iterator方法进行抽取，提高了扩展性。

一、高级for循环
  • 高级for循环：foreach语句，foreach简化了迭代器。
  • 语法：
    // 增强for循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器
    for( 元素类型 变量名 : Collection集合 & 数组 ) {
    …
    }
  • 高级for循环和传统for循环的区别：
    • 高级for循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。
    • 如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。
  • 高级for循环可以遍历map集合吗？不可以，但是可以将map转成set后再使用foreach语句。
  • 作用：对存储对象的容器进行迭代： 数组  collection   map
    1. 增强for循环迭代数组：
      String [] arr = {"a", "b", "c"};//数组的静态定义方式，只试用于数组首次定义的时候
      for(String s : arr) {
      System.out.println(s);
      }
    2. 单列集合 Collection：
      List list = new ArrayList();
      list.add("aaa");
      // 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？能
      for(Object obj : list) {
      String s = (String) obj;
      System.out.println(s);
      }
    3. 双列集合 Map：
      Map map = new HashMap();
      map.put("a", "aaa");
      // 增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，因为增强for循环只能针对实现了Iterable接口的集合进行迭代；Iterable是jdk5中新定义的接口，就一个方法iterator方法，只有实现了Iterable接口的类，才能保证一定有iterator方法，java有这样的限定是因为增强for循环内部还是用迭代器实现的，而实际上，我们可以通过某种方式来使用增强for循环。
      for(Object obj : map.entrySet()) {
      Map.Entry entry = (Entry) obj;  // obj 依次表示Entry
      System.out.println(entry.getKey() + "=" + entry.getValue());
      }
  • 集合迭代注意问题：在迭代集合的过程中，不能对集合进行增删操作（会报并发访问异常）；可以用迭代器的方法进行操作（子类listIterator：有增删的方法）。
  • 增强for循环注意问题：在使用增强for循环时，不能对元素进行赋值。
             int[] arr = {1,2,3};
             for(int num : arr) {
             num = 0; //不能改变数组的值
             }
             System.out.println(arr[1]); //2
二、可变参数
       可变参数（...）：用到函数的参数上，当要操作的同一个类型元素个数不确定的时候。 在传入时，每次都需要定义一个数组对象，作为实际参数。可是用这个方式，这个参数可以接受任意个数的同一类型的数据。
  • 和接收数组不一样的是：
    • 之前：定义数组类型，需要先创建一个数组对象，再将这个数组对象作为参数传递给函数。
    • 现在：直接将数组中的元素作为参数传递即可。底层其实是将这些元素进行数组的封装，而这个封装动作，是在底层完成的，被隐藏了。
    • 所以简化了用户的书写，少了调用者定义数组的动作。
  • 如果在参数列表中使用了可变参数，可变参数必须定义在参数列表结尾(也就是必须是最后一个参数，否则编译会失败)。
  • 如果要获取多个int数的和时，可以使用将多个int数封装到数组中，直接对数组求和即可。
class  ParamMethodDemo
{
	public static void main(String[] args) 
	{
		/*
		可变参数。
		其实就是上一种数组参数的简写形式。
		不用每一次都手动的建立数组对象。
		只要将要操作的元素作为参数传递即可。
		隐式将这些参数封装成了数组。
		*/
		show("zhangsan",1,3,5,5,9);
	}
	public static void show(String str,int... arr)
	{
		System.out.println(arr.length);
	}
}
三、静态导入
  • 写法：
    • import static java.util.Collections.*;  //导入了Collections类中的所有静态成员
    • import static java.util.Collections.sort;  //导入了Collections类中的静态成员sort。
  • 作用：
    • 导入了类中的静态成员，简化静态成员的书写。
  • 注意：
    • 当导入的两个类中有同名成员时，需要在成员前加上相应的类名。
    • 当类名重名时，需要指定具体的包名。
    • 当方法重名时，指定具体所属的对象或者类。

import static java.util.Collections.*;  
import static java.lang.System.*;  
class  CollectionsDemo3
{
	public static void main(String[] args) 
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		sort(list);//调用Collections类的sort方法
		out.println("max = " + max(list));//调用System类的out方法。
	}
}


第四讲 其他类

一、System类

  • System是描述系统一些信息的类，类中的属性和方法都是静态的。不能被实例化，没有提供构造函数。
    • out：标准输出流。默认是控制台。
    • in：标准输入流。默认是键盘。
  • 方法：
    • Properties  getProperties();获取系统的属性信息
      • 此方法返回的双列集合，即键值对；因为Properties是Hahstable的子类，也就是Map集合的一个子类对象，那么通过Map方法取出该集合中的元素。
      • 该集合存储的都是字符串，没有泛型定义。
    • String getProperty(Stringkey);获取指定属性信息
    • String setProperty(Stringkey,String value);在系统内定义特有信息
    • 如何在jvm启动时，加载一些属性信息：通过命令：java -D<name>=<value>可以设置特有的系统属性信息

import java.util.*;  
class SystemDemo   
{  
	public static void main(String[] args)   
	{  
		Properties prop = System.getProperties();//获取当前的系统属性  
		System.out.println(prop);   
		  
		String value = System.getProperty("os.name");//获取指定键指示的系统属性  
		System.out.println("os.name=" + value);  
		  
		System.setProperty("wode","LXZ_PC");//设置指定键指示的系统属性信息  
		System.out.println(prop);  
				  
		String str = System.getProperty("lix");//当系统中没有该键值，返回null  
		System.out.println(str);  
		  
	}  
}

二、 Runtime类

  • 特点
    • 每个java应用程序都有一个Runtime类实例，使用应用程序能与其中运行的环境相连接，应用程序不能创建自己的Runtime类的实例，是由系统底层自己创建的。
    • 该类中并没有提供构造函数。说明不可以new对象。
    • 该类中有非静态方法。说明该类肯定会提供了方法获取本来对象。而且该方法是静态的，并返回值类型是本来类型。
    • 由以上特点可以看出该类使用了单例设计模式完成。
  • 方法：
    • static RuntimegetRuntime();获取本类对象
    • Processexec(String command);在单独的进程中执行指定字符串命令
    • void destroy();在Process中有一个杀掉子进程的方法，可将exec方法开启的进程结束

class RuntimeDemo   
{  
    public static void main(String[] args)throws Exception  
    {  
        Runtime runing =Runtime.getRuntime();//获取本类对象  
  
        Process poce =r.exec("notepad.exe");//执行记事本程序  
        runing.exec("notepad.exe  RuntimeDemo.java");//用记事本打开指定文件  
  
        Thread.sleep(6000);//让线程等待6秒  
        poce.destroy();//杀掉指定进程  
    }  
}

三、时间类

1.Date类

  • Date类表示特定的瞬间，精确到毫秒。
  • Java中的默认显示格式为：Mon Nov 24 10:19:24 CST2014
  • 自定义格式
    • Java中默认的显示格式对于大多数人看着不习惯，我们可以根据自己的习惯来自定义时间格式。
    • 因为Date类中的大部分方法已过时，所以只能找其子类来实现。子类DateFormat中有format方法可以实现，但是DateFormat是抽象类，不能实例化。
    • 但是其下有个SimpleDateFormat子类，可以定义时间模式。
  • 具体步骤：
    1. 创建Date对象
    2. 将时间模式封装到SimpleDateFormat对象中
    3. 调用format方法让格式化模式指定Date对象

代码：

import java.util.*;  
import java.text.*;  
class DateDemo   
{  
    public static void main(String[] args)   
    {  
        Date d = new Date();//创建Date对象    
        //将模式封装到SimpleDateformat对象中。  
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日E HH:mm:ss");  
        //调用format方法让模式格式化指定Date对象。  
        String time=sdf.format(d);  
        System.out.println(ojb)time);  
    }  
}

2.Carendar类

  • Calendar是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH等日历字段之间的转换提供了一些方法。
  • Calendar可以对年月日等时间进行获取。并提供了相应的子段值。
  • 方法：
  • 基本获取时间
    • 获取年份：Calendar.YEAR
    • 获取月份：Calendar.MONTH
    • 获取日期：Calendar.DAY_OF_MONTH
    • 获取星期：Calendar.DAY_OF_WEEK
    • 获取小时：Calendar.HOUR_OF_DAY
    • 获取分钟：Calendar.MINUTE
    • 获取秒数：Calendar.SECOND
  • 设置时间：
    • 根据日历的规则，为给定的日历字段添加或减去指定的时间量： void add(int field,int amount);
    • 获取指定的日历字段对应的时间值：int get(int field);
    • 将给定日历字段对应的时间值设置为给定值：void set(int field,int value);
    • 设置日历字段 YEAR、MONTH和DAY_OF_MONTH的值：void set(int year,int month,int date);

import java.util.*;
import java.text.*;

class  CalendarDemo
{
	public static void main(String[] args) 
	{

		Calendar c = Calendar.getInstance();

		String[] mons = {"一月","二月","三月","四月"
					,"五月","六月","七月","八月"
					,"九月","十月","十一月","十二月"};

		String[] weeks = {
						"","星期日","星期一","星期二","星期三","星期四","星期五","星期六",
							};		
		int index = c.get(Calendar.MONTH);

		int index1 = c.get(Calendar.DAY_OF_WEEK);

		sop(c.get(Calendar.YEAR)+"年");
		//sop((c.get(Calendar.MONTH)+1)+"月");
		sop(mons[index]);
		sop(c.get(Calendar.DAY_OF_MONTH)+"日");
		//sop("星期"+c.get(Calendar.DAY_OF_WEEK));
		sop(weeks[index1]);
	}

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

四、Math 类，Random类

  •  Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
  • 该类全为静态方法。
    • doubleceil(double d);  返回大于指定数据的最小整数
    • doublefloor(double d);  返回小于指定数据的最大整数
    • double pow(doublea,double b);  返回a的b次方
    • long round(doubleb);  返回b四舍五入的值 
    • doublerandom();  返回正号的double值，是一个大于等于0.0且小于1.0的随机数
  •  Random类
    • java.util中的一个单独的类，该类对象用于获取随机数。
    • 与Math中的random方法是一样的，不过这个类有自身的方法，可以将相应的随机数强转为指定基本数据类型。
    • 如：intnextInt(int n);//返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。

import java.util.*;

class  MathDemo
{
	public static void main(String[] args) 
	{
		saveTwo(12.3456,3,true);//12.34
		show();
	}
	//给定一个小数。保留该小数的后两位。
	public static void saveTwo(double d,int scale,boolean isRound)
	{
		double base = Math.pow(10,scale);
		double num = isRound?Math.round(d*base)/base:((int)(d*base))/base;
		sop("num="+num);

	}

	public static void show()
	{
		double d = Math.ceil(16.34);//ceil返回大于指定数据的最小整数。
		double d1 = Math.floor(12.34);//floor返回小于指定数据的最大整数。

		long l = Math.round(12.54);//四舍五入
		sop("d="+d);
		sop("d1="+d1);
		sop("l="+l);

		double d2 = Math.pow(2,3);
		sop("d2="+d2);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}


------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------

huaiLxz
关注
专栏目录
Java后端开发（十六）-- JavaBean对象拷贝工具类：运用反射机制，实现对象的深拷贝
PUYALEI的博客
09-12 242
JavaBean对象拷贝工具类：运用反射机制，实现对象的深拷贝。
Java中的集合---------Collections 类---集合的工具类 Comparator比较器
norang的博客
03-27 232
Collections 2.1 常用功能 java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下： public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。 public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。 public static <T> void sort(Li
集合基础，练习练习
qq_45043813的博客
05-13 841
1.定义一个Collection接口类型的变量，引用一个List集合的实现类，实现添加单个元素，添加另一个集合，删除元素，判断集合中是否包含一个元素，判断是否为空，清除集合，返回集合里元素的个数等常用操作。 public class Work7_1_1 { public static void main(String[] args) { //定义一个Collection接口类型的变量，引用一个List集合的实现类 Collection collection = ne
JavaSE集合练习题
天问的博客
04-18 1638
JavaSE集合练习题简答编程参考文献 简答 1.Collection 和 Collections的区别 解：Collection是集合类的上级接口，继承于他的接口主要有 Set 和 List Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作 2.Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别 解：Set里的元素是不能重复的，用equals()方法判读两个Set是否相等 equals(
JavaSE集合练习
weixin_51985152的博客
03-15 968
集合练习实验要求实验过程 实验要求 1、集合Collection中存储的如果是自定义类的对象，需要自定义类重写哪个方法？为什么？​ 2、ArrayList,LinkedList,Vector三者的相同点和不同点​ 3、List接口的常用方法有哪些​ 4、Set存储数据的特点是什么？有哪些实现类，简述各实现类的特点​ 5、如何去除list中重复的数据​ 6、创建一个List集合的对象，添加几个数字，反转对象中元素的顺序；根据元素的自然顺序排序​ 7、一组数列A[25,36,17,23,14] ,一组数列B[1
Java 集合练习题（Collections 工具类的简单使用）
m0_57348761的博客
01-12 486
1.创建一个List集合的对象，添加几个数字，反转对象中元素的顺序； 根据元素的自然顺序排序；（可以指定要添加的元素类型如：Integer、Double、String） List<Integer> list = new ArrayList<>(); list.add(45); list.add(-98); list.add(7); System.out.println(list); .
集合练习1
weixin_53050118的博客
03-18 711
1、集合Collection中存储的如果是自定义类的对象，需要自定义类重写哪个方法？为什么？ 重写hashCode()方法和equals()方法。 为什么：向HashSet集合添加一个元素，首先会调用自定义类的hashCode()方法来确定元素的存储位置，然后再调用元素对象的equals()方法来确保该位置没有重复元素。 2、ArrayList,LinkedList,Vector三者的相同点和不同点 ArrayList数据结构本质是数组，查找元素的速度很优秀。 LinkedList数据结构本质是链表（双向链
Java基础---泛型、集合框架工具类：collections和Arrays
神之梦
08-31 4234
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------  第一讲     泛型（Generic） 一、概述 1、JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。 2、JDK1.5的集合类希望在定义集合时，明确表明你要向集合中装入那种类型的数据，无法加入指定类型以外的数据。 3、泛型是提供给javac编
Java基础——集合框架工具类(Collections类和Arrays类)
大道至簡的博客
05-13 1403
个人小结：集合框架工具类中常用的有Collections和Arrays，他们提供了很多封装好的静态方法，专门用于对集合数据的操作，非常方便快捷。
Java基础----集合类汇总
03-28
Java集合框架还包含了一些工具类，如Collections和Arrays，它们提供了各种实用方法，如排序、复制、反转和查找集合中的特定元素。此外，Set和List接口都有一个叫做CopyOnWriteArrayList和CopyOnWriteArraySet的特殊...
Java测试题
weixin_40212700的博客
08-28 369
1、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别 它们使用hashcode来区分是否重复，首先通过hashcode来判断是否重复，如果hashcode重复则判断equals是否相同则添加失败，不相同则添加到相同hashcode地方 2、List, Set, Map是否继承自Collection接口 List和set继承自Collecti...
将list集合的元素按照添加顺序的倒序进行排列取出
weixin_33974433的博客
01-06 2806
1.方法 Collections.reverse(list);     2.代码示例 /** * 从redis中将现场状态的记录全部取出 * @param aucId * @return */ @RequestMapping(value = "/findAllAuctionLocalStatementRecord", method = Reques...
实现List集合中数据逆序排列
热门推荐
谢栋的专栏
10-29 4万+
今天写项目时在listview展示数据时遇到一件很苦恼的事，因为listview中的数据是从调用者传递过来的List集合，里面的数据跟传过来的数据顺序保持一致 但是项目中的需求是想让最后添加进来的数据展示在listview的最顶端，即数据需要逆序排列，尝试了好多方法都觉得不大方便，其中也尝试了用for遍历里面 的数据，但是实现起来着实太麻烦。 其实Java作为一个强大的开发语言，自然是强大的
Java中对List集合内的元素进行顺序、倒序、随机排序
技术分享
10-16 5209
1 import java.util.Collections; 2 import java.util.LinkedList; 3 import java.util.List; 4 5 public class Test { 6 7 List list = new LinkedList(); 8 public static void main...
将List集合中的元素反转
u014080514的专栏
11-13 1万+
将ArrayList集合中的元素反转
Java 集合练习题
weixin_44193337的博客
01-18 4367
第一题：创建一个List集合的对象，添加几条数据，将1号位和2号位交换；获得最大值，最小值打印出来，最后再遍历该集合并把元素打印出来 public class ListDemo { /*创建一个List集合的对象，添加几条数据， 将1号位和2号位交换；获得最大值，最小值打印出来， 最后再遍历该集合并把元素打印出来*/ public static void main(String[] args) { //创建ArrayList对象 List li
将一个字符串数组的元素的顺序进行反转。
qizhichao110的专栏
02-02 2695
function myreverse(arr) {             for (var i = 0; i                 var temp = arr[i]; //交换变量                 arr[i] = arr[arr.length - i - 1];                 arr[arr.length-i-1]=temp;
JAVA学习
qq_45464043的博客
08-27 1252
这里写自定义欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdow
Java中对List集合内的元素进行顺序、倒序、随机排序的示例代码
weixin_30879833的博客
05-29 182
参考：https://www.cnblogs.com/jpwz/p/5692939.html import java.util.Collections; import java.util.LinkedList; import java.util.List; public class Test { List list = new Li...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值