Бун — «Простая самоуверенная Java для начинающего программиста Java-уровня». Boon — это структура »
Низкая Церемония. Высокая Производительность». Он призван стать «настоящим благом для Java для разработчиков!»

Многие языки имеют обозначения срезов (Ruby, Groovy и Python). Бун добавляет это в Java.

У Boon есть три
оператора slc :
slc ,
slc (только начало) и
slcEnd .

С Boon вы можете нарезать строки, массивы (примитивные и общие), списки, наборы, наборы деревьев, древовидные карты и многое другое. Эта статья объясняет обозначение среза и как оно реализовано в Boon. В нем показано, как использовать нотацию срезов с массивами, наборами, наборами деревьев и т. Д. Вы можете использовать нотацию Boon для простого поиска в TreeMaps и TreeSets. При использовании Boon нарезка примитивных массивов не использует автобокс, поэтому она очень эффективна.

Срезы обозначений — нежное введение

Операторы слайса Бун работают как
нотация Python / Ruby :

Рубиновая запись

  arr = [1, 2, 3, 4, 5, 6]
  arr[2]    #=> 3
  arr[-3]   #=> 4
  arr[2, 3] #=> [3, 4, 5]
  arr[1..4] #=> [2, 3, 4, 5]

Нотация Python

  string = "foo bar" 
  string [0:3]  #'foo'
  string [-3:7] #'bar'

То, что следует, получено из превосходной записи на
нотации Python :

Основы обозначений срезов следующие:

Нотация Python

         a[ index ]       # index of item
         a[ start : end ] # items start through end-1
         a[ start : ]     # items start through the rest of the array
         a[ : end ]       # items from the beginning through end-1
         a[ : ]           # a copy of the whole array

Обозначение фрагмента Java с использованием Boon :

          idx( index )         // index of item
          slc( a, start, end ) // items start through end-1
          slc( a, start )      // items start through the rest of the array
          slcEnd( a, end )     // items from the beginning through end-1
          copy( a )            // a copy of the whole array

slc обозначает ломтик
idx обозначает индекс
slcEnd обозначает конечный фрагмент .
копия означает хорошо, ээээ, копия конечно

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

Другая особенность заключается в том, что
начало или
конец может быть отрицательным числом, что означает, что оно отсчитывается от конца массива, а не от начала. Таким образом:

Нотация Python с отрицательным индексом

             a[ -1 ]    # last item in the array
             a[ -2: ]   # last two items in the array
             a[ :-2 ]   # everything except the last two items

Java отрицательный индекс

idx(a,-1)//lastiteminthearrayslc(-2)//lasttwoitemsinthearrayslcEnd(-2)//everythingexceptthelasttwoitems

Python и
Boon добры к программисту, если имеется меньше элементов, чем вы просили:
Python не позволяет вам выходить за пределы, если вы это делаете, он возвращает в худшем случае пустой список.
Boon следует этой традиции, но предоставляет возможность получить исключение за пределами (описано позже). В
Python и
Boon , если вы идете далеко, вы получите длину, если вы попытаетесь перейти ниже 0, вы получите 0 (ниже 0 после расчета). И наоборот, Ruby дает вам нулевой указатель (ноль). Boon копирует стиль Python, так как одна из целей Boon состоит в том,
чтобы никогда не возвращать null (вы получаете исключение, Option). (
Бун имеет второй оператор под названием
zlc который выбрасывает исключение индекса за пределами границ, но большинство людей должны использовать slc.)

Например, если вы запрашиваете
slcEnd (a, -2) (a [: — 2]) и
a содержит только один элемент, вместо ошибки вы получите пустой список. Иногда вы бы предпочли ошибку, и с Boon у вас есть такая возможность.

Больше нарезки

Вот некоторые основные типы Java, список, массив, овощи, массив примитивных символов и массив примитивных байтов.

Объявите переменные для работы в Boon

  //Boon works with lists, arrays, sets, maps, sorted maps, etc.
  List<String> fruitList;
  String [] fruitArray;
  Set<String> veggiesSet;
  char [] letters;
  byte [] bytes;
  NavigableMap <Integer, String> favoritesMap;
  Map<String, Integer> map;

  //In Java a TreeMap is a SortedMap and a NavigableMap by the way.

Boon поставляется с вспомогательными методами, которые позволяют легко создавать списки, наборы, карты, одновременные карты, отсортированные карты, отсортированные наборы и т. Д. Вспомогательные методы — это
safeList ,
list ,
set ,
sortedSet ,
safeSet ,
safeSortedSet и т. Д. Идея состоит в том, чтобы сделать Java более похожим на список и карты встроены в типы.

Инициализировать набор, список, массив строк, массив символов и массив байтов

  veggiesSet  =  set( "salad", "broccoli", "spinach");
  fruitList   =  list( "apple", "oranges", "pineapple");
  fruitArray  =  array( "apple", "oranges", "pineapple");
  letters     =  array( 'a', 'b', 'c');
  bytes       =  array( new byte[]{0x1, 0x2, 0x3, 0x4});

Существуют даже методы для создания карт и отсортированных карт, которые называются
map ,
sortedMap ,
safeMap (одновременный) и
sortedSafeMap (одновременный). Они были созданы главным образом потому, что в Java нет литералов для списков, карт и т. Д.

Java: используйте оператор map для генерации SortedMap <Integer, String> и карты <String, Integer>

   favoritesMap = sortedMap(
          2, "pineapple",
          1, "oranges",
          3, "apple"
   );
   map =    map (
      "pineapple",  2,
      "oranges",    1,
      "apple",      3
   );

Вы можете индексировать карты, списки, массивы и т. Д. С помощью
оператора idx .

Java: использование оператора Boon Java idx для получения значений по индексу

   //Using idx to access a value.

   assert idx( veggiesSet, "b").equals("broccoli");

   assert idx( fruitList, 1 ).equals("oranges");

   assert idx( fruitArray, 1 ).equals("oranges");

   assert idx( letters, 1 ) == 'b';

   assert idx( bytes, 1 )      == 0x2;

   assert idx( favoritesMap, 2 ).equals("pineapple");

   assert idx( map, "pineapple" )  == 2;

Операторы
idx работают и с отрицательными индексами.

Java: использование оператора idx с отрицательными значениями

             //Negative indexes

              assert idx( fruitList, -2 ).equals("oranges");

              assert idx( fruitArray, -2 ).equals("oranges");

              assert idx( letters, -2 ) == 'b';

              assert idx( bytes, -3 )   == 0x2;

Ruby, Groovy и Python имеют эту функцию. Теперь вы можете использовать это и в Java! Java-версия (Boon) работает с примитивными массивами, поэтому вы не получаете автобокс.

Что-то, чего нет в Ruby и Python, — это нотация срезов для SortedSets и SortedMaps.

Вы можете использовать обозначение среза для поиска отсортированных карт и наборов в Java

Срезы обозначений работают с отсортированными картами и отсортированными наборами.

Вот пример, который объединяет несколько концепций.

              set = sortedSet("apple", "kiwi", "oranges", "pears", "pineapple")

              slcEnd( set, "o" )      //returns ("oranges", "pears", "pineapple")
              slc( set, "ap", "o" )   //returns ("apple", "kiwi"),
              slc( set, "o" )         //returns ("apple", "kiwi")

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

Какой пункт идет после «пи»?

              after(set, "pi") //pineapple

А перед ананасом?

    before(set, "pi")

Хорошо, давай пройдемся по шагам ….

    NavigableSet<String> set = sortedSet("apple", "kiwi", "oranges", "pears", "pineapple"); assertEquals( "oranges", idx(set, "ora") );

TreeSet реализует
NavigableSet и
SortedSet .

Краткое напоминание, что TreeSet является NavigableSet

Мы можем найти первый фрукт в наборе, который начинается с ‘o’, используя:

   idx(set, "o")

Вот набор фруктов, который мы создали ранее (набор представляет собой TreeSet с «яблоком», «киви», «апельсинами», «грушами», «ананасами»).

    assertEquals( "oranges", idx(set, "o") );

Мы нашли апельсины!

Здесь снова, но на этот раз мы ищем фрукты, которые начинаются с «p», то есть
idx (set, «p») .

    assertEquals( "pears", idx(set, "p") );

Да уж! Мы нашли груши!

Как насчет фруктов, которые начинаются с «пи», как «ананас» —
idx (set, «pi»)

    assertEquals( "pineapple", idx(set, "pi") );

Вы также можете попросить товар после другого предмета. Что после «пи»?

после (установить, «пи»)

    assertEquals( "pineapple", after(set, "pi") );

«Ананас» идет после пункта «пи».
после и
idx , кстати, одинаковы. Так почему я добавил после? Так что я могу иметь до !!! ?

Что делать, если вы хотите знать, что перед «пи»?

до (установить, «пи»)

    assertEquals( "pears", before(set, "pi") );

Как насчет всех фруктов, которые находятся между «ап» и «о»? Как я и обещал, есть обозначение среза!

slc (set, «ap», «o»)

    assertEquals( sortedSet("apple", "kiwi"), slc(set, "ap", "o") );

Как насчет всех фруктов после «о»?

slc (set, «o»)

    assertEquals( sortedSet("apple", "kiwi"), slc(set, "o") );

Так что все фрукты после «о» — это «яблоко» и «киви».

Как насчет всех фруктов до «о»? (slcEnd прочитайте это, когда я нарезаю конец)

slcEnd (set, «o»)

    assertEquals( sortedSet("oranges", "pears", "pineapple"), slcEnd(set, "o") );

Таким образом, все фрукты, включая «o», включают «апельсины», «груши» и «ананасы».

Безопасная нарезка для списка, как вещи

Эти операторы выдают исключение, если индекс выходит за пределы:

Обозначение фрагмента Java следующим образом с использованием Boon:

    ix( index ) // index of item zlc( a, start, end ) // items start through end-1 zlc( a, start ) // items start through the rest of the array zlcEnd( a, end ) // items from the beginning through end-1

zlc обозначает срез с нулевым допуском
ix обозначает индекс нулевой терпимости
zlcEnd обозначает конец среза с нулевым допуском .
копия означает хорошо, ээээ, копия конечно

Работает с Примитивами тоже, поэтому нет автобокса

Индексирование примитивов

    byte[] letters = array((byte)'a', (byte)'b', (byte)'c', (byte)'d'); assertEquals( 'a', idx(letters, 0) ); assertEquals( 'd', idx(letters, -1) ); assertEquals( 'd', idx(letters, letters.length - 1) ); idx(letters, 1, (byte)'z'); assertEquals( (byte)'z', idx(letters, 1) );

Метод
len и
idx являются универсальными операторами и работают со списками, массивами, множествами, картами и т. Д.

Лен, дайте мне длину массива, списка, карты.
idx дает мне элемент в месте «индекса» в массиве, в виде списка, в виде карты.

HOME MC String Slice!

Вот несколько примеров Boon Java String Slicing

     String letters = "abcd"; boolean worked = true; worked &= idx(letters, 0) == 'a' || die("0 index is equal to a"); worked &= idx(letters, -1) == 'd' || die("-1 index is equal to a");

Другой способ выразить
idx (letters, -1) == ‘d’ — это
idx (letters, letters.length () — 1) == ‘d’!

Я предпочитаю более короткий путь!

     worked &= idx(letters, letters.length() - 1) == 'd' || die("another way to express what the -1 means"); //We can modify too letters = idx(letters, 1, 'z'); worked &= idx(letters, 1) == 'z' || die("Set the 1 index of letters to 'z'"); worked &= ( in('a', letters) && in('z', letters) ) || die("'z' is in letters and 'a' is in letters");

Ломтик ломтик детка!

     letters = "abcd"; worked &= slc(letters, 0, 2).equals("ab") || die("index 0 through index 2 is equal to 'ab'"); worked &= slc(letters, 1, -1).equals("bc") || die("index 1 through index (length -1) is equal to 'bc'"); worked &= slcEnd(letters, -2).equals("ab") || die("Slice of the end of the string!"); worked &= slcEnd(letters, 2).equals("ab") || die("Vanilla Slice Slice baby!");