элементов - сортировка массива java




Инициализация массива в одной строке (20)

Я хочу создать список вариантов для тестирования. Сначала я сделал это:

ArrayList<String> places = new ArrayList<String>();
places.add("Buenos Aires");
places.add("Córdoba");
places.add("La Plata");

Затем я реорганизовал код следующим образом:

ArrayList<String> places = new ArrayList<String>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Есть лучший способ сделать это?


Простой ответ

В Java 8 или ранее:

List<String> strings = Arrays.asList("foo", "bar", "baz");

Это даст вам List поддерживаемый массивом, поэтому он не может изменить длину.
Но вы можете вызвать List.set , поэтому он все еще изменчив.

В Java 9:

List<String> strings = List.of("foo", "bar", "baz");

Это даст вам неизменный List , поэтому его нельзя изменить.
Это то, что вы хотите, в большинстве случаев, когда вы его предварительно заполняете.

Более короткий ответ

Вы можете сделать Arrays.asList еще короче со статическим импортом:

List<String> strings = asList("foo", "bar", "baz");

Статический импорт:

import static java.util.Arrays.asList;  

Что любая современная IDE предложит и автоматически сделает для вас.
Например, в IntelliJ IDEA нажмите Alt+Enter и выберите Static import method...

Тем не менее, я не рекомендую List.of метод Java 9 List.of , потому что это просто запутывает.
List.of уже достаточно короткий и хорошо читается.

Использование Stream s

Почему это должен быть List ?
С помощью Java 8 или более поздней версии вы можете использовать Stream который является более гибким:

Stream<String> strings = Stream.of("foo", "bar", "baz");

Вы можете объединить Stream s:

Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
                                       Stream.of("baz", "qux"));

Или вы можете перейти из Stream в List :

List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());

Но предпочтительно, просто используйте Stream не собирая его в List .

Если вам действительно нужен java.util.ArrayList

(Вероятно, вы этого не сделаете.)
Процитировать JEP 269 (акцент мой):

Существует небольшой набор вариантов использования для инициализации экземпляра mutable collection с предопределенным набором значений. Обычно предпочтительнее, чтобы эти предопределенные значения находились в неизменяемой коллекции, а затем инициализировали изменчивую коллекцию с помощью конструктора копирования.

Если вы хотите как предварительно заполнить ArrayList и добавить к нему (почему?), Используйте

List<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");

или в Java 9:

List<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");

или используя Stream :

List<String> strings = Stream.of("foo", "bar")
                             .collect(toCollection(ArrayList::new));
strings.add("baz");

Но опять же, лучше просто использовать Stream непосредственно, а не собирать его в List .

Программа для интерфейсов, а не для реализации

Вы сказали, что объявили список как ArrayList в своем коде, но вы должны сделать это только в том случае, если вы используете какой-то член ArrayList , которого нет в List .

Скорее всего, вы этого не делаете.

Обычно вам нужно просто объявить переменные самым общим интерфейсом, который вы собираетесь использовать (например, Iterable , Collection или List ), и инициализировать их с помощью конкретной реализации (например, ArrayList , LinkedList или Arrays.asList() ).

В противном случае вы ограничиваете свой код этим конкретным типом, и его будет сложнее изменить, когда захотите.

Например:

// Iterable if you just need iteration, for (String s : strings):
Iterable<String> strings = new ArrayList<>();   

// Collection if you also need .size() or .stream():
Collection<String> strings = new ArrayList<>(); 

// List if you also need .get(index):
List<String> strings = new ArrayList<>();       

// Don't declare a specific list implementation
// unless you're sure you need it:
ArrayList<String> strings = new ArrayList<>();  // You don't need ArrayList

Другим примером всегда будет объявление переменной InputStream хотя обычно это FileInputStream или BufferedInputStream , потому что однажды вы или кто-то захотите использовать какой-то другой тип InputStream .


(Должен быть комментарий, но слишком длинный, так что новый ответ). Как Arrays.asList другие, метод Arrays.asList имеет фиксированный размер, но это не единственная проблема с ним. Он также не справляется с наследованием очень хорошо. Например, предположим, что у вас есть следующее:

class A{}
class B extends A{}

public List<A> getAList(){
    return Arrays.asList(new B());
}

Вышеприведенные результаты приводят к ошибке компилятора, поскольку List<B> (это то, что возвращается Arrays.asList) не является подклассом List<A> , хотя вы можете добавить объекты типа B в объект List<A> , Чтобы обойти это, вам нужно сделать что-то вроде:

new ArrayList<A>(Arrays.<A>asList(b1, b2, b3))

Вероятно, это лучший способ сделать это, особенно. если вам нужен неограниченный список или нужно использовать наследование.


Было бы проще, если бы вы просто объявили его как List - это должен быть ArrayList?

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Или, если у вас есть только один элемент:

List<String> places = Collections.singletonList("Buenos Aires");

Это будет означать, что places являются неизменяемыми (попытка изменить это приведет к исключению исключения UnsupportedOperationException ).

Чтобы создать измененный список, являющийся конкретным ArrayList вы можете создать ArrayList из неизменяемого списка:

ArrayList<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

В Java 9 мы можем легко инициализировать ArrayList в одной строке:

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

или же

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Этот новый подход Java 9 имеет много преимуществ по сравнению с предыдущими:

  1. Эффективность пространства
  2. Immutability
  3. Потоковое Сейф

См. Это сообщение для получения дополнительной информации -> В чем разница между List.of и Arrays.asList?


Вот еще один способ:

List<String> values = Stream.of("One", "Two").collect(Collectors.toList());

Вот код от AbacusUtil

// ArrayList
List<String> list = N.asList("Buenos Aires", "Córdoba", "La Plata");
// HashSet
Set<String> set = N.asSet("Buenos Aires", "Córdoba", "La Plata");
// HashMap
Map<String, Integer> map = N.asMap("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// Or for Immutable List/Set/Map
ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// The most efficient way, which is similar with Arrays.asList(...) in JDK. 
// but returns a flexible-size list backed by the specified array.
List<String> set = Array.asList("Buenos Aires", "Córdoba", "La Plata");

Декларация: Я разработчик AbacusUtil.


Вы можете использовать приведенные ниже инструкции:

Фрагмент кода:

String [] arr = {"Sharlock", "Homes", "Watson"};

List<String> names = Arrays.asList(arr);

Вы можете создать фабричный метод:

public static ArrayList<String> createArrayList(String ... elements) {
  ArrayList<String> list = new ArrayList<String>();
  for (String element : elements) {
    list.add(element);
  }
  return list;
}

....

ArrayList<String> places = createArrayList(
  "São Paulo", "Rio de Janeiro", "Brasília");

Но это не намного лучше, чем ваш первый рефакторинг.

Для большей гибкости он может быть общим:

public static <T> ArrayList<T> createArrayList(T ... elements) {
  ArrayList<T> list = new ArrayList<T>();
  for (T element : elements) {
    list.add(element);
  }
  return list;
}

Для меня Arrays.asList () - лучший и удобный. Мне всегда нравится инициализировать этот путь. Если вы новичок в сборниках Java, я бы хотел, чтобы вы ссылались на инициализацию ArrayList


Если вам нужен простой список размером 1:

List<String> strings = new ArrayList<String>(Collections.singletonList("A"));

Если вам нужен список из нескольких объектов:

List<String> strings = new ArrayList<String>();
Collections.addAll(strings,"A","B","C","D");

Литералы коллекции не попали в Java 8, но можно использовать Stream API для инициализации списка в одной довольно длинной строке:

List<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toList());

Если вам нужно убедиться, что ваш List является ArrayList :

ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new));

Лучший способ сделать это:

package main_package;

import java.util.ArrayList;


public class Stackkkk {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<Object>();
        add(list, "1", "2", "3", "4", "5", "6");
        System.out.println("I added " + list.size() + " element in one line");
    }

    public static void add(ArrayList<Object> list,Object...objects){
        for(Object object:objects)
            list.add(object);
    }
}

Просто создайте функцию, которая может иметь столько элементов, сколько вы хотите, и назовите ее, чтобы добавить их в одну строку.


О самом компактном способе сделать это:

Double array[] = { 1.0, 2.0, 3.0};
List<Double> list = Arrays.asList(array);

Попробуйте использовать эту строку кода:

Collections.singletonList(provider)

Просто используйте ниже код следующим образом.

List<String> list = new ArrayList<String>() {{
            add("A");
            add("B");
            add("C");
}};

С Guava вы можете написать:

ArrayList<String> places = Lists.newArrayList("Buenos Aires", "Córdoba", "La Plata");

В Guava есть и другие полезные статические конструкторы. Вы можете прочитать о них here .


С Java 9 , как предложено в JDK Enhancement Proposal - 269 , это может быть достигнуто с использованием коллекционных литералов в настоящее время -

List<String> list = List.of("A", "B", "C");

Set<String> set = Set.of("A", "B", "C");

Аналогичный подход применим и к Map -

Map<String, String> map = Map.of("k1", "v1", "k2", "v2", "k3", "v3")

который аналогичен предложению Collection Literals, как указано в @coobird. Далее уточняется в документе JEP, а также -

альтернативы

Языковые изменения были рассмотрены несколько раз и отклонены:

Предложение по проектной монете, 29 марта 2009 г.

Предложение по проектному монете, 30 марта 2009 г.

Обсуждение JEP 186 на лямбда-dev, январь-март 2014 года

Предложения по языку были отложены в предпочтении к предложению, основанному на библиотеке, в кратком изложении этого message.

Дальше прочитайте => В чем смысл перегруженных методов фабрики для коллекций в Java 9


Собственно, это можно сделать в одной строке:

Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})

List<String> names = Arrays.asList("2","@2234","21","11");

import com.google.common.collect.ImmutableList;

....

List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");




initialization