IT

알파벳순으로 목록을 정렬하려면 어떻게해야합니까?

lottoking 2020. 5. 29. 08:07
반응형

알파벳순으로 목록을 정렬하려면 어떻게해야합니까?

List<String>국가 이름이 포함 된 개체가 있습니다. 이 목록을 알파벳순으로 정렬하려면 어떻게해야합니까?

그것들이 문자열이라고 가정하면 편리한 정적 메소드를 사용하십시오 sort...

 java.util.Collections.sort(listOfCountryNames)

Collections.sort가있는 솔루션

해당 목록을 사용해야하는 경우 또는 프로그램의 구조가 다음과 같은 경우

  • 리스트 작성
  • 일부 국가 이름 추가
  • 한 번 정렬
  • 해당 목록을 다시 변경하지 마십시오

그런 다음 Thilos의 답변이 최선의 방법입니다. Tom Hawtin-tackline 의 조언과 결합하면 다음과 같은 이점 이 있습니다.

java.util.Collections.sort(listOfCountryNames, Collator.getInstance());

TreeSet을 사용한 솔루션

자유롭게 결정할 수 있고 응용 프로그램이 더 복잡해지면 TreeSet을 대신 사용하도록 코드를 변경할 수 있습니다. 이러한 종류의 컬렉션은 항목을 삽입 할 때만 정렬합니다. sort ()를 호출 할 필요가 없습니다.

Collection<String> countryNames = 
    new TreeSet<String>(Collator.getInstance());
countryNames.add("UK");
countryNames.add("Germany");
countryNames.add("Australia");
// Tada... sorted.

TreeSet을 선호하는 이유에 대한 참고 사항

여기에는 미묘하지만 중요한 장점이 있습니다.

  • 더 짧습니다. 그러나 단 한 줄만 짧습니다.
  • 걱정하지 마십시오 . TreeSet이 항상 정렬 되기 때문에이 목록이 실제로 정렬되어 있기 때문에 걱정 하지 마십시오.
  • 중복 된 항목을 가질 수 없습니다. 상황에 따라 이것은 찬반 양론 일 수 있습니다. 중복이 필요하면 목록을 고수하십시오.
  • 숙련 된 프로그래머 가보고 TreeSet<String> countyNames즉시 알고 있습니다 : 이것은 복제본이없는 정렬 된 문자열 모음이며 매 순간마다 이것이 사실임을 확신 할 수 있습니다 . 짧은 선언에 많은 정보가 있습니다.
  • 어떤 경우에는 실제 성능이 승리합니다. List를 사용하고 값을 매우 자주 삽입하고 해당 삽입 사이에서 목록을 읽을 수있는 경우 삽입 할 때마다 목록을 정렬해야합니다. 세트는 동일하지만 훨씬 빠릅니다.

올바른 작업에 올바른 컬렉션을 사용하는 것은 짧고 버그가없는 코드를 작성하는 데 중요합니다. 이 경우 한 줄만 저장하기 때문에 실증적이지 않습니다. 그러나 중복이 없는지 확인하려는 사람이 목록을 사용하는 빈도를 세고 그 기능을 직접 구축했습니다. 또는 더 나쁜 것은 실제로지도가 필요할 때 두 개의 목록을 사용하는 것입니다.

잘못 이해하지 마십시오. Collections.sort 사용은 오류나 결함이 아닙니다. 그러나 TreeSet가 훨씬 더 깨끗한 경우가 많이 있습니다.

Java 8 Stream 또는 Guava를 사용하여 새로운 정렬 사본을 만들 수 있습니다.

// Java 8 version
List<String> sortedNames = names.stream().sorted().collect(Collectors.toList());
// Guava version
List<String> sortedNames = Ordering.natural().sortedCopy(names);

또 다른 옵션은 Collections API를 통해 내부 정렬하는 것입니다.

Collections.sort(names);

안하는 것보다 늦게하는 것이 낫다! 우리가 할 수있는 방법은 다음과 같습니다 (학습 목적으로 만).

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

class SoftDrink {
    String name;
    String color;
    int volume; 

    SoftDrink (String name, String color, int volume) {
        this.name = name;
        this.color = color;
        this.volume = volume;
    }
}

public class ListItemComparision {
    public static void main (String...arg) {
        List<SoftDrink> softDrinkList = new ArrayList<SoftDrink>() ;
        softDrinkList .add(new SoftDrink("Faygo", "ColorOne", 4));
        softDrinkList .add(new SoftDrink("Fanta",  "ColorTwo", 3));
        softDrinkList .add(new SoftDrink("Frooti", "ColorThree", 2));       
        softDrinkList .add(new SoftDrink("Freshie", "ColorFour", 1));

        Collections.sort(softDrinkList, new Comparator() {
            @Override
            public int compare(Object softDrinkOne, Object softDrinkTwo) {
                //use instanceof to verify the references are indeed of the type in question
                return ((SoftDrink)softDrinkOne).name
                        .compareTo(((SoftDrink)softDrinkTwo).name);
            }
        }); 
        for (SoftDrink sd : softDrinkList) {
            System.out.println(sd.name + " - " + sd.color + " - " + sd.volume);
        }
        Collections.sort(softDrinkList, new Comparator() {
            @Override
            public int compare(Object softDrinkOne, Object softDrinkTwo) {
                //comparision for primitive int uses compareTo of the wrapper Integer
                return(new Integer(((SoftDrink)softDrinkOne).volume))
                        .compareTo(((SoftDrink)softDrinkTwo).volume);
            }
        });

        for (SoftDrink sd : softDrinkList) {
            System.out.println(sd.volume + " - " + sd.color + " - " + sd.name);
        }   
    }
}

에 대한 두 개의 인수를 사용하십시오 Collections.sort. Comparator통해 얻을 수있는 것과 같이 대소 문자를 적절하게 처리하는 (즉, UTF16 순서가 아닌 어휘를 수행 하는) 적합 을 원할 것 java.text.Collator.getInstance입니다.

악센트없는 영어로만 문자열을 정렬하지 않는 한을 사용하는 것이 Collator좋습니다. 발음 구별 부호를 올바르게 정렬하고 대소 문자 및 기타 언어 관련 내용을 무시할 수 있습니다.

Collections.sort(countries, Collator.getInstance(new Locale(languageCode)));

collator 강도를 설정할 수 있습니다 ( javadoc 참조).

다음은 슬로바키아의 예입니다.

List<String> countries = Arrays.asList("Slovensko", "Švédsko", "Turecko");

Collections.sort(countries);
System.out.println(countries); // outputs [Slovensko, Turecko, Švédsko]

Collections.sort(countries, Collator.getInstance(new Locale("sk")));
System.out.println(countries); // outputs [Slovensko, Švédsko, Turecko]

한 줄로 Java 8을 사용하십시오. 

list.sort(Comparator.naturalOrder());

여기 당신이 찾고있는 것입니다

listOfCountryNames.sort(String::compareToIgnoreCase)

를 사용하여 Collections.sort()목록을 정렬 할 수 있습니다.

public class EmployeeList {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        List<String> empNames= new ArrayList<String>();

        empNames.add("sudheer");
        empNames.add("kumar");
        empNames.add("surendra");
        empNames.add("kb");

        if(!empNames.isEmpty()){

            for(String emp:empNames){

                System.out.println(emp);
            }

            Collections.sort(empNames);

            System.out.println(empNames);
        }
    }
}

산출:

sudheer
kumar
surendra
kb
[kb, kumar, sudheer, surendra]

내림차순 알파벳 :

List<String> list;
...
Collections.sort(list);
Collections.reverse(list);

자바 8에서 동일 :-

//Assecnding order
        listOfCountryNames.stream().sorted().forEach((x) -> System.out.println(x));

//Decending order
        listOfCountryNames.stream().sorted((o1, o2) -> o2.compareTo(o1)).forEach((x) -> System.out.println(x));

//Here is sorted List alphabetically with syncronized
package com.mnas.technology.automation.utility;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import org.apache.log4j.Logger;
/**
* 
* @author manoj.kumar
*/
public class SynchronizedArrayList {
static Logger log = Logger.getLogger(SynchronizedArrayList.class.getName());
@SuppressWarnings("unchecked")
public static void main(String[] args) {

List<Employee> synchronizedList = Collections.synchronizedList(new ArrayList<Employee>());
synchronizedList.add(new Employee("Aditya"));
synchronizedList.add(new Employee("Siddharth"));
synchronizedList.add(new Employee("Manoj"));
Collections.sort(synchronizedList, new Comparator() {
public int compare(Object synchronizedListOne, Object synchronizedListTwo) {
//use instanceof to verify the references are indeed of the type in question
return ((Employee)synchronizedListOne).name
.compareTo(((Employee)synchronizedListTwo).name);
}
}); 
/*for( Employee sd : synchronizedList) {
log.info("Sorted Synchronized Array List..."+sd.name);
}*/

// when iterating over a synchronized list, we need to synchronize access to the synchronized list
synchronized (synchronizedList) {
Iterator<Employee> iterator = synchronizedList.iterator();
while (iterator.hasNext()) {
log.info("Sorted Synchronized Array List Items: " + iterator.next().name);
}
}

}
}
class Employee {
String name;
Employee (String name) {
this.name = name;

}
}

내가 만든 방법을 사용해보십시오.

String key - will be the order you want and in this case in alphabetically. Just put "abc...".

String list[] - the list you want to put in order using key.

int index - set as 0, will set the offset for the key.

    public static String[] order(String key, String list[], int index) {
    ArrayList<String> order_List = new ArrayList<String>();
    ArrayList<String> temp_Order_List = null;
    char[] key_char = key.toCharArray();
    for (int offset = 0; offset < key_char.length; offset++) {
        if (key_char.length >= offset + index) {
            String str = (index > 1 ? list[0].substring(0, index - 1) : "")
                    + new String(key_char, offset, 1);
            for (int i = 0; i < list.length; i++) {
                temp_Order_List = new ArrayList<String>();
                for (int k = 0; k < list.length; k++) {
                    if (!order_List.contains(list[k])
                            && !temp_Order_List.contains(list[k])) {
                        if (list[k].equalsIgnoreCase(str))
                            order_List.add(list[k]);
                        else if (list[k].toLowerCase().startsWith(str.toLowerCase())) {
                            temp_Order_List.add(list[k]);

                        }
                    }
                }
                if (temp_Order_List.size() > 0) {
                    if (temp_Order_List.size() > 1) {
                        String[] add = order(key,
                                temp_Order_List.toArray(new String[temp_Order_List
                                        .size()]), index + 1);
                        for (String s : add) {
                            order_List.add(s);
                        }
                    } else {
                        order_List.add(temp_Order_List.get(0));
                    }
                }
            }
        }
    }
    return order_List.toArray(new String[order_List.size()]);
}

참고URL : https://stackoverflow.com/questions/708698/how-can-i-sort-a-list-alphabetically

반응형

'IT' 카테고리의 다른 글

SQL Server에서 저장 프로 시저 또는 함수의 마지막 변경 날짜를 확인하는 방법  (0) 2020.05.29
잡히지 않은 구문 오류 : JSON.parse가있는 예기치 않은 토큰  (0) 2020.05.29
큰 Ө 표기법은 정확히 무엇을 의미합니까?  (0) 2020.05.29
ASP.NET MVC :이 개체에 대해 매개 변수가없는 생성자가 정의되어 있지 않습니다  (0) 2020.05.29
백업을 복원 할 때 모든 활성 연결을 해제하려면 어떻게합니까?  (0) 2020.05.29

'IT'의 다른글

  • 현재글알파벳순으로 목록을 정렬하려면 어떻게해야합니까?

관련글

댓글

티스토리툴바