精华内容
下载资源
问答
  • java集合排序练习

    2020-05-09 10:10:06
    任务 1、给list添加元素 2、输出排序前list中的内容 3、对list中的元素进行排序 4、输出排序后list中的内容 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class ...

    选择题

    1.BC
    2.D
    3.D

    编程题

    1. 对英文单词进行排序,效果图如下:
      任务 1、给list添加元素 2、输出排序前list中的内容 3、对list中的元素进行排序 4、输出排序后list中的内容
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    public class StringSort {
    	public static void main(String[] args) {
    		//给list添加元素 
    		List<String> list = new ArrayList<String>();	
    		list.add("orange");
    		list.add("tomato");
    		list.add("apple");
    		list.add("litchi");
    		list.add("banana");
    		//输出排序前list中的内容 
    		System.out.println("排序前:");
    		for(String s : list) {
    			System.out.print(s + " ");
    		}
    		//对list中的元素进行排序   
    		Collections.sort(list);		
    		//输出排序后list中的内容   
    		System.out.println();
    		System.out.println("排序后:");
    		for(String s : list) {
    			System.out.print(s + " ");
    		}
    	}
    }
    
    1. 定义一个学生信息类,包括学号,姓名,年龄三个成员变量,然后按名字进行升序排序。(使用 Comparator接口)
    public class Student {
    	private int id;
    	private String name;
    	private int age;
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	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;
    	}
    
    	public Student() {
    		super();
    	}
    
    	public Student(int id, String name, int age) {
    		super();
    		this.id = id;
    		this.name = name;
    		this.age = age;
    	}
    
    	@Override
    	public String toString() {
    		return "[学号:" + id + ", 年龄:" + age + ", 姓名:" + name + "]";
    	}
    
    	
    }
    
    import java.util.Comparator;
    
    public class NameComparator implements Comparator<Student> {
    
    	@Override
    	public int compare(Student arg0, Student arg1) {
    		String name1 = arg0.getName();
    		String name2 = arg1.getName();
    		int n = name1.compareTo(name2);
    		
    		return n; 
    	}
    	
    }
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    public class StudentTest {
    	public static void main(String[] args) {
    		Student s1 = new Student(40, "peter", 20);
    		Student s2 = new Student(28, "angel", 5);
    		Student s3 = new Student(35, "tom", 18);
    		
    		List<Student> list = new ArrayList<Student>();
    		list.add(s1);
    		list.add(s2);
    		list.add(s3);
    		
    		System.out.println("按名字排序前:");
    		for(Student s : list) {
    			System.out.println(s);
    		}
    		//按名字进行升序排序后
    		Collections.sort(list, new NameComparator());
    		System.out.println("按名字排序后:");
    		for(Student s : list) {
    			System.out.println(s);
    		}
    	}
    }
    
    1. 定义一个员工信息类,包括编号,姓名,工资三个成员变量,要求工资定义为float类型,然后按 工资进行降序排序。(使用Comparable接口)
    public class Employee implements Comparable<Employee> {
    	private String id;
    	private String name;
    	private float money;
    
    	public String getId() {
    		return id;
    	}
    
    	public void setId(String id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public float getMoney() {
    		return money;
    	}
    
    	public void setMoney(float money) {
    		this.money = money;
    	}
    
    	public Employee() {
    		super();
    	}
    
    	public Employee(String id, String name, float money) {
    		super();
    		this.id = id;
    		this.name = name;
    		this.money = money;
    	}
    
    	@Override
    	public String toString() {
    		return "员工 [编号:" + id + ", 姓名:" + name + ", 工资:" + money + "]";
    	}
    
    	@Override
    	public int compareTo(Employee arg0) {
    		float m1 = this.getMoney();
    		float m2 = arg0.getMoney();
    		int n = new Float(m2 - m1).intValue();
    		return n;
    	}
    	
    }
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    public class EmployeeTest {
    	public static void main(String[] args) {
    		Employee y1 = new Employee("emp001", "张三", 1800.0f);
    		Employee y2 = new Employee("emp002", "李四", 2500.0f);
    		Employee y3 = new Employee("emp003", "王五", 1600.0f);
    		
    		List<Employee> list = new ArrayList<Employee>();
    		list.add(y1);
    		list.add(y2);
    		list.add(y3);
    		
    		System.out.println("排序前:");
    		for(Employee e : list) {
    			System.out.println(e);
    		}
    		
    		System.out.println("排序后:");
    		Collections.sort(list);
    		for(Employee e : list) {
    			System.out.println(e);
    		}
    	}
    }
    
    展开全文
  • 下面要大家分享的是一个小米...volatile在Java并发编程中常用于保持内存可见性和防止指令重排序2、常用Java集合List 列表,有序,可重复;Queue 队列,有序,可重复;Set 集合,不可重复;Map映射,无序,键唯一,...

    下面要给大家分享的是一个小米java社招的面试经验,内容包括了一面二面的面试题,对小米java社招感兴趣的小伙伴可以来了解一下。

    面试题(一面)

    1、volatile关键字的作用是什么?原理是什么?

    volatile在Java并发编程中常用于保持内存可见性和防止指令重排序

    2、常用Java集合类

    List 列表,有序,可重复;Queue 队列,有序,可重复;Set 集合,不可重复;Map

    映射,无序,键唯一,值不唯一每种集合类型下都包含多个具体的实现类。

    3、Java synchronized关键字的作用是什么?原理,锁升级、锁粗化、锁消除

    4、二分查找(递归和非递归)

    5、反转链表(递归和非递归)

    6、事务的ACID,每一项是怎样保证的?

    7、HashMap为什么长度是2的n次幂,数据结构,扩容(包括元素移动的细节),线程不安全的问题

    8、ConcurrentHashMap怎么保证线程安全,1.7和1.8有什么变化,为什么要要这么优化

    9、CopyOnWriteList怎么保证线程安全,为什么这么做?

    10、MVCC

    11、MySQL的索引结构,为什么是B+树而不是B树?

    B树在提高IO性能的同时,并没与解决元素遍历时效率低下的问题,正是为了解决这个问题,B+数应运而生。

    B+数只需遍历叶子节点即可实现整棵树的遍历,而B树必须使用中序遍历按序扫库,B+树支持范围查询非常方便。这才是数据库选用B+树的主要原因。

    面试题(二面)

    1、求递增数组中相加等于10的元素对

    2、先升序后降序的数组排序

    3、一个url对应一个random值,要求设计一个系统,依据url查询random值,具体到表如何设计?索引如何加?代码如何写?

    4、17^400-19100计算结果能不能被10整除

    5、讲项目,画架构图,为什么这么设计?哪一块是你做的?为什么这么做?做了多久?

    以上就是小米java社招面试经验的分享了,更多小米java面经面试题,请继续来本站了解吧。

    展开全文
  • ------- android培训、java培训、期待与您交流! ---------- 主要内容:一、二集合框架的工具类:Collections,Arrays;三、集合变数组;四、高级for循环;五、方法的可变参数;...按自然顺序给list集合排序

    ------- android培训java培训、期待与您交流! ----------

    主要内容:一、二集合框架的工具类:Collections,Arrays;三、集合变数组;四、高级for循环;五、方法的可变参数;六、静态导入
    一、Collections:集合框架的工具类:方法都是静态的

        
        1,Collections.sort(list);按自然顺序给list集合排序。
           Collections.sort(list, Comparator);根据指定比较器产生的顺序对指定列表进行排序。


        例:按自然顺序排序 和 按长度排序。

    import java.util.*;
    class  CollectionsDemo
    {
    	public static void main(String[] args) 
    	{
    		sortDemo();
    	}
    
    	public static void sortDemo()
    	{
    		List<String> list = new ArrayList<String>();
    		
    		list.add("abcd");
    		list.add("aaa");
    		list.add("zz");
    		list.add("kkkkk");
    		list.add("qq");
    
    		sop(list);
    
    		Collections.sort(list);//按自然顺序排序。
    		sop(list);
    
    		Collections.sort(list,new StrLenComparator());//将比较器传进来,按长度排序
    
    		sop(list);
    	}
    
    	public static void sop(Object obj)
    	{
    		System.out.println(obj);
    	}
    }
    
    //设定一个比较器,按长度排序
    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);
    	}
    }
    
        2,Collections.max(list);集合中最大的元素。
        例:求集合中最大元素,注意:可以自己制定一个比较器,如上例中的长度比较器

    import java.util.*;
    class  CollectionsDemo
    {
    	public static void main(String[] args) 
    	{
    		maxDemo();
    	}
    
    	public static void maxDemo()
    	{
    		List<String> list = new ArrayList<String>();
    		
    		list.add("abcd");
    		list.add("aaa");
    		list.add("zz");
    		list.add("kkkkk");
    		list.add("qq");
    		
    		Collections.sort(list);
    		sop(list);
    
    		String max = Collections.max(list/*,new StrLenComparator()*/);//可指定比较器。
    		sop("max="+max);
    	}
    }
    

        3,Collections.binarySearch(list,"aaa");二分查找指定元素,返回角标值。注意:必须是有序集合。
                     如果搜索键包含在列表中,则返回搜索键的索引;否则返回 (-(插入点) - 1)。


    例:查找指定元素,返回角标值。注意:必须是有序集合。

    import java.util.*;
    class  CollectionsDemo
    {
    	public static void main(String[] args) 
    	{
    		binarySearchDemo();
    	}
    
    	public static void binarySearchDemo()
    	{
    		List<String> list = new ArrayList<String>();
    		
    		list.add("abcd");
    		list.add("aaa");
    		list.add("zz");
    		list.add("kkkkk");
    		list.add("qq");
    		
    		Collections.sort(list);//排序
    		sop(list);
    		
    		int index = Collections.binarySearch(list,"aaa");//二分查找"aaa",返回角标值
    		sop("index="+index);
    	}
    }
    

        演示折半查找原理:例

        //折半查找原理
    	public static int halfSearch(List<String> list,String key)
    	{
    		int max,min,mid;
    		max = list.size();
    		min = 0;
    
    		while(min<=max)
    		{
    			mid = (max+min)>>1;//   /2;
    			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;//没找着,返回插入(角标)再减1;
    	}
    

        4,Collections.fill(list,"pp");使用指定元素替换指定列表中的所有元素。


        练习。fill方法可以将list集合中所有元素替换成指定元素。
    	public static void fillDemo()
    	{
    		List<String> list = new ArrayList<String>();
    
    		list.add("abcd");
    		list.add("aaa");
    		list.add("ccc");
    		list.add("zzzz");
    
    		sop(list);
    		Collections.fill(list,"pp");//将集合中的元素,都替换成指定元素。
    
    		sop(list);
    	}
    

        5,Collections.replaceAll(list,"aaa","pp");使用另一个值替换列表中出现的所有某一指定值。

        	public static void replaceAllDemo()
    	{
    		List<String> list = new ArrayList<String>();
    
    		list.add("abcd");
    		list.add("aaa");
    		list.add("ccc");
    		list.add("zzzz");
    
    		sop(list);
    		Collections.replaceAll(list,"aaa","pp");
    		sop(list);
    	}
    

        6,reverse(List<?> list); 反转指定列表中元素的顺序。


        7,reverseOrder() 
              返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。


           reverseOrder(Comparator<T> cmp) 
              返回一个比较器,它强行逆转指定比较器的顺序。
        例:

    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);//长度相同,按字符串自然顺序排序。
    	}
    }
    class  CollectionsDemo2
    {
    	public static void main(String[] args) 
    	{
    		orderDemo();
    	}
    
    	public static void orderDemo()
    	{
    		//强行逆转,按字符串长度,倒序排序。
    		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
    
    		ts.add("abcde");
    		ts.add("aaa");
    		ts.add("ccc");
    		ts.add("zz");
    		ts.add("q");
    
    		Iterator it = ts.iterator();
    		while(it.hasNext())
    		{
    			sop(it.next());
    		}
    	}
    }
    

        8,synchronizedList(List<T> list);返回指定列表支持的同步(线程安全的)列表。


        9,swap(List<?> list, int i, int j); 在指定列表的指定位置处交换元素。


        10,shuffle(List<?> list);使用默认随机源对指定列表进行置换。
        例:实际应用:如扑克牌,色子等

        	public static void shuffleDemo()
    	{
    		List<String> list = new ArrayList<String>();
    
    		list.add("abcde");
    		list.add("aaa");
    		list.add("ccc");
    		list.add("zzz");
    
    		sop(list);
    		Collections.shuffle(list);
    		sop(list);
    
    	}
    

    二、Arrays:用于操作数组的工具类。里面都是静态方法。


        1,toString();返回指定数组内容的字符串表示形式。
        例:

    import java.util.*;
    class  ArraysDemo
    {
    	public static void main(String[] args) 
    	{
    		int[] arr = {2,3,4};
    
    		sop(Arrays.toString(arr));//数组转成字符串。
    	}
    	public static void sop(Object obj)
    	{
    		System.out.println(obj);
    	}
    }
    

        2,asList:将数字变成list集合。
           
         2.1 把数组变成list集合有什么好处?

    可以使用集合的思想和方法来操作数组中的元素。

    注意:将数组变成集合,不可以使用集合的增删方法。
    因为数组的长度是固定的。
    可以使用:
    contains
    get
    indexOf()
    subList()



    如果增删,那么会发生不支持操作异常:UnsupportedOperationException


         2.2 如果数组中元素都是对象,那么变成集合时,数组中的元素就直接转成集合中的元素。
    如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。


    例:

    import java.util.*;
    class  ArraysDemo
    {
    	public static void main(String[] args) 
    	{
    		String[] arr = {"abc","dd","dfaf"};
    		//把数组变成list集合有什么好处?
    		/*
    		可以使用集合的思想和方法来操作数组中的元素。
    		注意:将数组变成集合,不可以使用集合的增删方法。
    		因为数组的长度是固定的。
    		可以使用:
    		contains
    		get
    		indexOf()
    		subList()
    		等
    
    		如果增删,那么会发生不支持操作异常:UnsupportedOperationException
    		*/
    		List<String> list = Arrays.asList(arr);
    		sop("contains:"+list.contains("dd"));
    		//list.add("qq");//UnsupportedOperationException:不支持的操作异常
    		sop(list);
    
    		int[] nums = {2,3,5};
    
    		List<int[]> li = Arrays.asList(nums);
    		/*
    		如果数组中元素都是对象,那么变成集合时,数组中的元素就直接转成集合中的元素。
    		如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。
    		*/
    
    		sop(li);//打印结果是数组的哈希值
    	}
    	public static void sop(Object obj)
    	{
    		System.out.println(obj);
    	}
    }
    

    三、集合变数组:
        1,指定类型的数组到底要定义多长呢?
    当指定类型的数组长度小于了集合的size,那么该方法内部会创建一个新的数组,长度为集合的size。
    当指定类型的数组长度大于了集合的size,就不会新创建了数组。而是使用传递进来的数组。
    所以创建一个刚刚好的数组最优。


        2,为什么要将集合变数组?
    为了限定对元素的操作。不需要进行增删了。


    例:

    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()]);//集合转数组
    
    		sop(Arrays.toString(arr));//打印数组字符串表现形式。
    
    	}
    	public static void sop(Object obj)
    	{
    		System.out.println(obj);
    	}
    }
    

    四、高级for循环。


        1, 格式:
            for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
            {


            }


        2,对集合进行遍历。
           只能获取集合元素。但是不能对集合进行操作。


           迭代器除了遍历,还可以进行remove集合中元素的动作。
           如果使用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。


        3,传统for和高级for有什么区别呢?
           高级for有一个局限性,必须由被遍历的目标。
           建议在遍历数组的时候还是希望使用传统for,因为传统for可以定义角标。
    例:

    import java.util.*;
    class  ForEachDemo
    {
    	public static void main(String[] args) 
    	{
    		ArrayList<String> al = new ArrayList<String>();
    
    		al.add("abc1");
    		al.add("abc2");
    		al.add("abc3");
    		
    		for(String s : al)
    		{
    			sop(s);
    		}
    		/*
    		Iterator it = al.iterator();
    		while(it.hasNext())
    		{
    			sop(it.next());
    		}
    		*/
    		int[] arr = {3,6,5};
    		for(int a : arr)
    		{
    			sop("a="+a);
    		}
    
    		HashMap<Integer,String> hm = new HashMap<Integer,String>();
    
    		hm.put(1,"abc1");
    		hm.put(2,"abc2");
    		hm.put(3,"abc3");
    
    		Set<Integer> keySet = hm.keySet();
    		for(Integer i : keySet)
    		{
    			sop(i+"::"+hm.get(i));
    		}
    
    		//Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
    		//for(Map.Entry<Integer,String> me : entrySet)
    
    		for(Map.Entry<Integer,String> me : hm.entrySet())
    		{
    			sop(me.getKey()+"----"+me.getValue());
    		}
    
    	}
    	public static void sop(Object obj)
    	{
    		System.out.println(obj);
    	}
    }
    

    五、方法的可变参数。JDK1.5版本出现的新特性。


        1,方法的可变参数。
           其实就是数组参数的简写形式。
           不用每一次都手动的建立数组对象。
           只有将要操作的元素作为参数传递即可。
           隐式将这些参数封装成了数组。


        2,方法的可变参数:
           在使用时注意:可变参数一定要定义在参数列表的最后面。
    例:

    import java.util.*;
    class  ParamMethodDemo
    {
    	public static void main(String[] args) 
    	{
    		show("haha",2,3,4,5,6);
    		//show(2,3,4,5,6,7,32,6,4);
    		//show();
    	}
    	public static void show(String str,int...arr)
    	{
    		System.out.println(Arrays.toString(arr));
    		System.out.println(arr.length);
    		System.out.println(str);
    	}
    }
    

    六、静态导入:
        1,StaticImport    静态导入。



           当类名重名时,需要指定具体的包名。
           当方法重名时,指定具备所属的对象或者类。
    例:

    import java.util.*;
    import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
    
    import static java.lang.System.*;//导入了System类中所有静态成员。
    class  StaticImport extends Object
    {
    	public static void main(String[] args) 
    	{
    		int[] arr = {3,1,5};
    
    		sort(arr);//排序:Arrays.sort(arr);
    		int index = binarySearch(arr,1);//二分查找:Arrays.binarySearch(arr,1);
    		out.println(Arrays.toString(arr));
    		System.out.println("Index="+index);
    
    	}
    }
    



    展开全文
  • 欢迎大家推荐自己觉得不错的 Java 项目,下面项目的排序很大程度是根据当前项目的 Star 数量。 如果有码云上比较好的项目的话,我也会推荐到这里来!另外,我也会推荐少部分过于优秀但是非开源的优质 Java 项目。 ...
  • Java开发技术大全(500个源代码).

    热门讨论 2012-12-02 19:55:48
    listFields.java 利用反射机制获取成员属性列表 listMethods.java 利用反射机制获取成员方法列表 loadClass.java 动态装载一个类 Shape.java 一个用于测试的简单类 useArray1.java 用反射机制使用数组示例1 ...
  • 疯狂JAVA讲义

    2014-10-17 13:35:01
    7.1 Java集合概述 241 7.2 Collection和Iterator接口 243 7.2.1 使用Iterator接口遍历集合元素 244 7.2.2 使用foreach循环遍历集合元素 246 7.3 Set接口 247 7.3.1 HashSet类 247 学生提问:hashCode方法对于...
  • java面试宝典

    2013-02-28 16:04:01
    94、元素有一个cascade属性,如果希望Hibernate级联保存集合中的对象,casecade属性应该取什么值?(单选)(D) 22 95、以下哪些属于Session的方法?(A,B,C,D,F) 22 96、Hibernate工作原理及为什么要用? 22 97、...
  • java范例开发大全

    2013-03-08 20:06:54
    实例218 使用Collections类对List排序操作 393 实例219 LinkedList的添加删除操作 395 实例220 运用Vector 397 实例221 改变Properties文件中的键值 399 第13章 多线程编程(教学视频:121分钟) 405 13.1 多线程...
  • java 面试题 总结

    2009-09-16 08:45:34
    Collections是针对集合类的一个帮助类,他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。 10、&和&&的区别。 &是位运算符,表示按位与运算,&&是逻辑运算符,表示逻辑与(and)。 11、HashMap...
  • 看需求,需要前端提供4部分内容,转换思想,其实就是提供4个List集合就好,那么我到底该怎么处理后端数据,让其能对号入座呢? 很简单,自己的思想就是首先必须获取每个数据的首字母,然后将其进行排序判断,然后...

    最近在新迭代的版本中,遇到这么几个需求,其实核心涉及到的还是最基本的Java基础或者函数,本次将自己近期的需求做法给予分享一下:
    一、需求图
    看需求,需要给前端提供4部分内容,转换思想,其实就是提供4个List集合就好,那么我到底该怎么处理后端数据,让其能对号入座呢?
    很简单,自己的思想就是首先必须获取每个数据的首字母,然后将其进行排序判断,然后对应座位即可,下边分享自己的demo。
    工具类:

    public class FirstLetterUntil {
        private static int BEGIN = 45217;
        private static int END = 63486;
        // 按照声母表示,这个表是在GB2312中的出现的第一个汉字,也就是说“啊”是代表首字母a的第一个汉字。
        // i, u, v都不做声母, 自定规则跟随前面的字母
        private static char[] chartable = {'啊', '芭', '擦', '搭', '蛾', '发', '噶', '哈',
                '哈', '击', '喀', '垃', '妈', '拿', '哦', '啪', '期', '然', '撒', '塌', '塌',
                '塌', '挖', '昔', '压', '匝',};
        // 二十六个字母区间对应二十七个端点
        // GB2312码汉字区间十进制表示
        private static int[] table = new int[27];
        // 对应首字母区间表
        private static char[] initialtable = {'a', 'b', 'c', 'd', 'e', 'f', 'g',
                'h', 'h', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
                't', 't', 'w', 'x', 'y', 'z',};
        // 初始化
        static {
            for (int i = 0; i < 26; i++) {
                table[i] = gbValue(chartable[i]);// 得到GB2312码的首字母区间端点表,十进制。
            }
            table[26] = END;// 区间表结尾
        }
        /**
         * 根据一个包含汉字的字符串返回一个汉字拼音首字母的字符串 最重要的一个方法,思路如下:一个个字符读入、判断、输出
         */
        public static String getFirstLetter(String sourceStr) {
            String result = "";
            String str = sourceStr.toLowerCase();
            int StrLength = str.length();
            int i;
            try {
                for (i = 0; i < StrLength; i++) {
                    result += Char2Initial(str.charAt(i));
                }
            } catch (Exception e) {
                result = "";
            }
            return result;
        }
        /**
         * 输入字符,得到他的声母,英文字母返回对应的大写字母,其他非简体汉字返回 '0'
         */
        private static char Char2Initial(char ch) {
            // 对英文字母的处理:小写字母转换为大写,大写的直接返回
            if (ch >= 'a' && ch <= 'z') {
                return ch;
            }
            if (ch >= 'A' && ch <= 'Z') {
                return ch;
            }
            // 对非英文字母的处理:转化为首字母,然后判断是否在码表范围内,
            // 若不是,则直接返回。
            // 若是,则在码表内的进行判断。
            int gb = gbValue(ch);// 汉字转换首字母
            if ((gb < BEGIN) || (gb > END))// 在码表区间之前,直接返回
            {
                return ch;
            }
            int i;
            for (i = 0; i < 26; i++) {// 判断匹配码表区间,匹配到就break,判断区间形如“[,)”
                if ((gb >= table[i]) && (gb < table[i + 1])) {
                    break;
                }
            }
            if (gb == END) {//补上GB2312区间最右端
                i = 25;
            }
            return initialtable[i]; // 在码表区间中,返回首字母
        }
        /**
         * 取出汉字的编码 cn 汉字
         */
        private static int gbValue(char ch) {// 将一个汉字(GB2312)转换为十进制表示。
            String str = new String();
            str += ch;
            try {
                byte[] bytes = str.getBytes("GB2312");
                if (bytes.length < 2) {
                    return 0;
                }
                return (bytes[0] << 8 & 0xff00) + (bytes[1] & 0xff);
            } catch (Exception e) {
                return 0;
            }
        }

    自己的测试类:

    public static void main(String[] args) throws ParseException {
            // Collator 类是用来执行区分语言环境的 String 比较的,这里选择使用CHINA
            Comparator comparator = Collator.getInstance(java.util.Locale.CHINA);
            //设置的假数据
            String[] arrStrings = {"阿狸", "小白", "乖乖", "羊宝宝", "猴崽子", "王四", "宝贝"};
            //定义的4个list集合
            List<String> firstList = new ArrayList<>();
            List<String> secondList = new ArrayList<>();
            List<String> thirdList = new ArrayList<>();
            List<String> lastList = new ArrayList<>();
            //一一取出,进行判断
            for (int i = 0; i < arrStrings.length; i++) {
                String a = arrStrings[i];
                String first1 = FirstLetterUntil.getFirstLetter(a).substring(0, 1);
                if (first1.equals("a") || first1.equals("b") || first1.equals("c") || first1.equals("d") || first1.equals("e") || first1.equals("f")) {
                    firstList.add(a);
                }
                if (first1.equals("i") || first1.equals("g") || first1.equals("k") || first1.equals("l") || first1.equals("m") || first1.equals("n")) {
                    secondList.add(a);
                }
                if (first1.equals("o") || first1.equals("p") || first1.equals("q") || first1.equals("r") || first1.equals("s") || first1.equals("t")) {
                    thirdList.add(a);
                }
                if (first1.equals("u") || first1.equals("v") || first1.equals("w") || first1.equals("x") || first1.equals("y") || first1.equals("z")) {
                    lastList.add(a);
                }
            }
            System.out.println(firstList);
            System.out.println(secondList);
            System.out.println(thirdList);
            System.out.println(lastList);
        }

    最后的输出结果:

    输出结果
    这样,在前端只需要一一获取list集合则可以满足需求。
    二:谈到根据字母获取信息的需求,除此之外,还有一个是直接从A到Z一一获取的,就和手机通讯录一样,两种想法,一种无空返回,就是说字母Z下边无数据,那么前端就不显示字母Z;另一种是A-Z都显示,若没数据,则显示为空;相比上个要求,英文字母分四段显示,需求上是复杂了些许,但是代码上确实提炼了许多,我们只需要通过K—Value的形式,对号入座即可。

    public static void main(String[] args) throws ParseException {
            //设置的假数据
            String[] arrStrings = {"阿狸", "阿宝", "小白", "乖乖","网络","杨树", "羊宝宝", "猴崽子", "王四", "宝贝"};
            Map<Object, String> map = new HashMap<>();
            for (int i = 0; i < arrStrings.length; i++) {
                //获取对应的集合
                String myStr = arrStrings[i];
                //获取第一个字母
                String myKey = FirstLetterUntil.getFirstLetter(myStr).substring(0, 1);
                //判定首字母是否相同,相同,放到同一个value中
                if (map.containsKey(myKey)){
                    map.put(myKey,map.get(myKey)+","+myStr);
                }else {
                    map.put(myKey,myStr);
                }
            }
            System.out.println(map);

    看输出结果:
    输出结果
    三:由于结算的需求,我需要将A表信息通过id整合一下,存入到B表中,意思就是说假如A表中id为1234的数据有4条,我需要汇总一下条数,以及里边的部分字段的求和然后以id为关联字段,创建一条记录放入B表中;也就是说B表中我每个id只有一条数据来汇总。
    我使用的主要的思想就是set去重的思想,比如A表中Id=1234的有4条;Id=4567的有5条,汇总到set集合中,我也仅仅有两条数据而已;至于数量的汇总,使用了collections的方法。
    看核心代码:

      public static int frequency(Collection<?> c, Object o) {
            int result = 0;
            if (o == null) {
                for (Object e : c)
                    if (e == null)
                        result++;
            } else {
                for (Object e : c)
                    if (o.equals(e))
                        result++;
            }
            return result;
        }

    整个需求的部分代码:

    Set set = new HashSet(supplierIdList);
                for (Object s : set) {
                    int thingsCounts = 0;
                    double rate = 0;
                    //计算不同的供应商id对应的个数
                    int count = Collections.frequency(supplierIdList, s);
                    }

    好多需求都是看java 基础的,基础扎实,真的是什么都不怕解决啊。借此激励自己,加油!

    转载于:https://www.cnblogs.com/huohuoL/p/10545458.html

    展开全文
  • Java经典编程300例(code)

    千次下载 热门讨论 2013-01-09 10:26:53
    实例102 用List集合传递学生信息 153 实例103 Map集合二级联动 155 实例104 不重复随机数组排序 157 实例105 for循环遍历ArrayList 159 实例106 Iterator遍历ArrayList 159 实例107 ListIterator逆序遍历ArrayList ...
  • 最新Java面试宝典pdf版

    热门讨论 2011-08-31 11:29:22
    JAVA实现一个快速排序。 79 11、有数组a[n],用java代码将数组元素顺序颠倒 80 12.金额转换,阿拉伯数字的金额转换成中国传统的形式如:(¥1011)->(一千零一拾一元整)输出。 81 三. html&JavaScript&ajax...
  • Java面试宝典2010版

    2011-06-27 09:48:27
    JAVA实现一个快速排序。 11、有数组a[n],用java代码将数组元素顺序颠倒 80 12.金额转换,阿拉伯数字的金额转换成中国传统的形式如:(¥1011)->(一千零一拾一元整)输出。 三. html&JavaScript&ajax部分 1...
  • Java 面试宝典

    2013-02-01 10:02:08
    内容到底变了没有? ..................................................................................................... 23 32、是否可以继承 String 类? ..................................................
  • JAVA面试题最全集

    2010-03-13 13:09:10
    一、Java基础知识 1.Java有那些基本数据类型,String是不是基本数据类型,他们有何区别。 2.字符串的操作: 写一个方法,实现字符串的反转,如:输入abc,输出cba 写一个方法,实现字符串的替换,如:输入...
  • java范例开发大全源代码

    热门讨论 2011-10-30 23:31:51
     第12章 集合(教学视频:45分钟) 358  12.1 Set 358  实例204 利用HashSet删除学生 358  实例205 不重复的随机数序列 360  实例206 运用映射的相关类(Map) 363  实例207 运用集的相关类(Set) ...
  • JAVA实现一个快速排序。 79 11、有数组a[n],用java代码将数组元素顺序颠倒 80 12.金额转换,阿拉伯数字的金额转换成中国传统的形式如:(¥1011)->(一千零一拾一元整)输出。 81 三. html&JavaScript&ajax...
  • Java范例开发大全 (源程序)

    热门讨论 2011-04-27 07:47:22
     实例218 使用Collections类对List排序操作 393  实例219 LinkedList的添加删除操作 395  实例220 运用Vector 397  实例221 改变Properties文件中的键值 399  第13章 多线程编程(教学视频:121分钟) ...
  • Java范例开发大全(全书源程序)

    热门讨论 2013-04-05 11:50:26
    实例218 使用Collections类对List排序操作 393 实例219 LinkedList的添加删除操作 395 实例220 运用Vector 397 实例221 改变Properties文件中的键值 399 第13章 多线程编程(教学视频:121分钟) 405 13.1 ...
  • Collections是针对集合类的一个帮助类,他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。 13、&和&&的区别。 &是位运算符,表示按位与运算,&&是逻辑运算符,表示逻辑与(and)。 14、...
  • Java开发实战1200例.第2卷.part3

    热门讨论 2013-05-08 22:46:34
    实例033 使用SAX组件解析XML元素名称和内容 58 实例034 使用SAX组件解析XML元素属性和 属性值 61 实例035 使用DOM组件解析XML元素属性和 属性值 62 实例036 使用SAX验证DTD 64 实例037 使用dom4j解析XML文件 66 第2...
  • Java开发实战1200例.第2卷.part2

    热门讨论 2013-05-08 22:45:35
    实例033 使用SAX组件解析XML元素名称和内容 58 实例034 使用SAX组件解析XML元素属性和 属性值 61 实例035 使用DOM组件解析XML元素属性和 属性值 62 实例036 使用SAX验证DTD 64 实例037 使用dom4j解析XML文件 66 第2...
  • Java开发实战1200例.第2卷.part1

    热门讨论 2013-05-08 22:44:13
    实例033 使用SAX组件解析XML元素名称和内容 58 实例034 使用SAX组件解析XML元素属性和 属性值 61 实例035 使用DOM组件解析XML元素属性和 属性值 62 实例036 使用SAX验证DTD 64 实例037 使用dom4j解析XML文件 66 第2...
  • 实例057 用List集合传递学生信息 70 实例058 用TreeSet生成不重复自动排序 随机数组 71 实例059 Map映射集合实现省市级联选择框 73 第4章 字符串处理技术 75 4.1 格式化字符串 76 实例060 把数字格式化为货币字符串 ...
  • 实例057 用List集合传递学生信息 70 实例058 用TreeSet生成不重复自动排序 随机数组 71 实例059 Map映射集合实现省市级联选择框 73 第4章 字符串处理技术 75 4.1 格式化字符串 76 实例060 把数字格式化为货币字符串 ...
  • 实例057 用List集合传递学生信息 实例058 用TreeSet生成不重复自动排序随机数组 实例059 Map映射集合实现省市级联选择框 第4章 字符串处理技术 4.1 格式化字符串 实例060 把数字格式化为货币字符串 实例061 ...
  • 实例057 用List集合传递学生信息 实例058 用TreeSet生成不重复自动排序随机数组 实例059 Map映射集合实现省市级联选择框 第4章 字符串处理技术 4.1 格式化字符串 实例060 把数字格式化为货币字符串 实例061 ...

空空如也

空空如也

1 2 3
收藏数 51
精华内容 20
关键字:

java给list集合内容排序

java 订阅