¿Hay un equivalente en Java al Easy String Splicing de Python?
reverse string python (8)
Ok, lo que quiero saber es si Java puede hacer lo que Python puede hacer a continuación ...
string_sample = "hello world"
string_sample[:-1]
>>> "hello world"
string_sample[-1]
>>> "d"
string_sample[3]
>>> "l"
Porque me parece que Java te hace trabajar por el mismo resultado (particularmente estoy teniendo que usar 2 números cada vez y la falta de un -1 para indicar el último carácter)
String string_sample = "hello world";
string_sample.substring(0,string_sample.length()-1);
>>> "hello world"
string_sample.substringstring_sample.length()];
>>> "d"
string_sample.(3,4);
>>> "l"
Todavía no he llegado a los arreglos / listas en Java, así que realmente espero que Java tenga algo más fácil que esto.
Edición: Se enmendó ''i'' a ''l'' para string_sample [3]. Maroun bien visto!
Creo que no hay tal biblioteca de cadenas Java que proporcione exactamente lo mismo que Python. Probablemente lo mejor que puedes hacer es construir una nueva clase que proporcione las funciones que necesitas. Dado que la String en java es una clase final de la cual no puede extenderse una clase, debe usar la composición. Por ejemplo:
public class PythonString {
protected String value;
public PythonString(String str) {
value = new String(str);
}
public char charAt(int index) {
if (index < 0) {
return value.charAt(value.length() + index);
}
return value.charAt(index);
}
....
}
Otra alternativa es crear una biblioteca de cadenas estática.
He creado una biblioteca simple para eso, llamada JavaSlice , que brinda una manera uniforme de acceder a segmentos de String, List o arrays en Java, de manera similar a Python.
Así que sus ejemplos se escribirían simplemente así:
String sample = "hello world";
System.out.println(slice(sample, 0, -1)); // "hello worl"
System.out.println(slice(sample, -1)); // ''d''
System.out.println(slice(sample, 3)); // ''l''
Java Boon Slice Notation permite todo eso y con cadenas, listas, conjuntos, mapas, etc.
Muchos idiomas tienen notación de división (Ruby, Groovy y Python). Boon agrega esto a Java.
Boon tiene tres operadores slc: slc , slc (solo inicio) y slcEnd .
Con Boon puede dividir cadenas, arreglos (primitivos y genéricos), listas, conjuntos, conjuntos de árboles, mapas de árboles y más.
Notaciones de la rebanada - una introducción suave
Los operadores de división de bonificación funcionan como la notación de división de Python / Ruby:
Notación de rubí
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]
Notación de la porción de Python
string = "foo bar"
string [0:3] #''foo''
string [-3:7] #''bar''
Lo que sigue se deriva de un excelente informe sobre la notación de corte de Python:
Los fundamentos de las notaciones de corte son los siguientes:
Python Slice Notation
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 Slice Notation usando 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 significa slice idx significa índice slcEnd significa rodaja final. Copiar significa bien, err, um copia por supuesto
El punto clave a recordar es que el valor final representa el primer valor que no se encuentra en el sector seleccionado. Entonces, la diferencia entre el final y el inicio es el número de elementos seleccionados. La otra característica es que el inicio o el final puede ser un número negativo, lo que significa que cuenta desde el final de la matriz en lugar del principio.
Así:
Notación de la porción de Python con índice negativo
a[ -1 ] # last item in the array
a[ -2: ] # last two items in the array
a[ :-2 ] # everything except the last two items
Índice negativo de Java
idx ( a, -1) // last item in the array
slc ( -2 ) // last two items in the array
slcEnd( -2 ) // everything except the last two items
Python y Boon son amables con el programador si hay menos elementos de los que solicita: Python no le permite salir de los límites, si lo hace, en el peor de los casos, devuelve una lista vacía. Boon sigue esta tradición, pero proporciona una opción para obtener una excepción para fuera de límites (que se describe más adelante). En Python y Boon, si vas lejos, obtienes la longitud, si intentas ir por debajo de 0, obtienes 0 (por debajo de 0 después del cálculo). Por el contrario, Ruby te da un puntero nulo (nulo). Boon copia el estilo de Python como uno de los objetivos de Boon es evitar volver nulo (obtienes una excepción, Opción). (Boon tiene un segundo operador llamado zlc que lanza una excepción de índice fuera de límites, pero la mayoría de la gente debería usar slc).
Por ejemplo, si solicita slcEnd (a, -2) (a [: - 2]) y solo contiene un elemento, obtendrá una lista vacía en lugar de un error. A veces preferirías el error, y con Boon tienes esa opción.
Más rebanar
Aquí hay algunos tipos básicos de Java, lista, matriz, veggies, matriz de caracteres primitivos y una matriz de bytes primitiva.
Declarar variables para trabajar en 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 viene con métodos de ayuda que le permiten crear fácilmente listas, conjuntos, mapas, mapas concurrentes, mapas ordenados, conjuntos ordenados, etc. Los métodos de ayuda son la lista segura, lista, conjunto, ordenada, segura, segura, clasificada, segura, etc. Haga que Java se sienta más como una lista y los mapas están integrados en tipos.
Inicialice el conjunto, la lista, el conjunto de cadenas, el conjunto de caracteres y el conjunto de bytes
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});
Incluso hay métodos para crear mapas y mapas ordenados llamados map, sortedMap, safeMap (concurrent) y sortedSafeMap (concurrent). Estos se crearon principalmente porque Java no tiene literales para listas, mapas, etc.
Java: utilizar el operador de mapas para generar un mapa de mapa y un mapa
favoritesMap = sortedMap(
2, "pineapple",
1, "oranges",
3, "apple"
);
map = map (
"pineapple", 2,
"oranges", 1,
"apple", 3
);
Puede indexar mapas, listas, matrices, etc. utilizando el operador idx.
Java: uso del operador idx de Boon Java para obtener los valores en un índice
//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;
Los operadores idx también funcionan con índices negativos.
Java: utilizando el operador idx con valores negativos
//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 y Python tienen esta característica. ¡Ahora también puedes usar esto en Java! La versión de Java (Boon) funciona con matrices primitivas para que no tengas auto-boxeo .
Algo que Ruby y Python no tienen es la notación de división para SortedSets y SortedMaps. Puede usar notación de división para buscar mapas ordenados y conjuntos ordenados en Java
Las notaciones de división funcionan con mapas ordenados y conjuntos ordenados.
Aquí hay un ejemplo que reúne algunos conceptos.
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")
Lo que realmente está haciendo con la segmentación de mapas ordenados y los conjuntos ordenados es una especie de consulta. ¿Qué artículo viene después de "pi"?
after(set, "pi") //pineapple
¿Y antes de la piña?
before(set, "pi")
Ok, déjalo ir paso a paso ...
NavigableSet<String> set =
sortedSet("apple", "kiwi", "oranges", "pears", "pineapple");
assertEquals(
"oranges", idx(set, "ora")
);
Recuerde: TreeSet implementa NavigableSet y SortedSet.
Esto fue derivado de mi blog ....
http://rick-hightower.blogspot.com/2013/10/java-slice-notation-to-split-up-strings.html
Más ejemplos están ahí.
Derivé parte de la palabrería de esta discusión sobre el corte de Python.
Explique la notación de corte de Python.
Aquí está el enlace del proyecto Boon:
https://github.com/RichardHightower/boon
Ahora vamos a SLICE!
Podemos buscar la primera fruta en el set que comienza con ''o'' usando:
idx(set, "o")
Aquí está el conjunto de frutas que creamos anteriormente (el conjunto es un TreeSet con "manzana", "kiwi", "naranjas", "peras", "piña" en él).
assertEquals(
"oranges", idx(set, "o")
);
Encontramos naranjas!
Aquí está otra vez, pero esta vez estamos buscando frutas que comiencen con "p", es decir, idx (set, "p").
assertEquals(
"pears",
idx(set, "p")
);
¡Sí! ¡Encontramos peras!
¿Qué hay de las frutas que comienzan con una "pi" como "piña" - idx (set, "pi")
assertEquals(
"pineapple",
idx(set, "pi")
);
También puede solicitar el elemento que está después de otro elemento. ¿Qué hay después de "pi"? después (set, "pi")
assertEquals(
"pineapple",
after(set, "pi")
);
La "piña" está después del ítem "pi". After y Idx son los mismos por cierto. Entonces, ¿por qué agregué un después? Así que puedo tener un antes !!! :) ¿Qué pasa si quieres saber qué hay antes de "pi"?
antes (set, "pi")
assertEquals(
"pears",
before(set, "pi")
);
¿Qué hay de todas las frutas que están entre "ap" y "o"? Como lo prometí hay notación de corte!
slc (set, "ap", "o")
assertEquals(
sortedSet("apple", "kiwi"),
slc(set, "ap", "o")
);
¿Qué tal todas las frutas después de la "o"?
slc (set, "o")
assertEquals(
sortedSet("apple", "kiwi"),
slc(set, "o")
);
Así que todas las frutas después de "o" son "manzana" y "kiwi".
¿Qué tal todas las frutas hasta "o"? (SlcEnd leerlo mientras estoy cortando el final.)
slcEnd (set, "o")
assertEquals(
sortedSet("oranges", "pears", "pineapple"),
slcEnd(set, "o")
);
Así que todas las frutas hasta e incluyendo "o" son "naranjas", "peras" y "piña".
Segmento seguro para la lista como cosas
Estos operadores lanzan una excepción si el índice está fuera de límites:
Java Slice Notation como sigue usando 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 representa la división de tolerancia cero ix representa el índice de tolerancia cero zlcEnd representa la división final de tolerancia cero. Copiar significa bien, err, um copia por supuesto
Niños y niñas ... recuerde siempre realizar cortes seguros con objetos que no conozca.
Funciona con primitivos también, así que no hay auto-boxeo
Primitivas de indexación
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)
);
Los métodos len e idx son operadores universales y funcionan en listas, matrices, conjuntos, mapas, etc.
len dame la longitud de una cosa parecida a una matriz, como una lista, como un mapa. idx me da el elemento en la ubicación de un "índice" en el tipo de matriz, de tipo de lista, de mapa.
Inicio MC String Slice!
Aquí hay algunos ejemplos de 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");
Otra forma de expresar idx (letras, -1) == ''d'' es idx (letters, letters.length () - 1) == ''d''! ¡Prefiero el camino más corto!
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");
Slice Slice Baby!
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!");
Rodando en mi 5.0, conseguí mi trapo de arriba abajo para que mi cabello pueda volar. Slice Slice Baby !!!
Lo sentimos, la substring de Java no es tan flexible como la notación de segmento de Python.
En particular:
- Puede darle solo un comienzo, un comienzo y un final, pero no solo un final. (Además, no hay paso, pero no te lo pierdes tanto).
- Los índices negativos son un error, no un recuento desde el final.
Puedes ver los documentos here .
Sin embargo, no es nada difícil escribir esto por tu cuenta:
public String slice_start(String s, int startIndex) {
if (startIndex < 0) startIndex = s.length() + startIndex;
return s.substring(startIndex);
}
public String slice_end(String s, int endIndex) {
if (endIndex < 0) endIndex = s.length() + endIndex;
return s.substring(0, endIndex);
}
public String slice_range(String s, int startIndex, int endIndex) {
if (startIndex < 0) startIndex = s.length() + startIndex;
if (endIndex < 0) endIndex = s.length() + endIndex;
return s.substring(startIndex, endIndex);
}
Ponerlos como métodos estáticos de alguna clase de utilidad.
Obviamente, esto no es exactamente lo mismo que Python, pero probablemente maneja todos los casos que desee, y es muy simple. Si desea manejar otros casos de borde (que incluyen cosas como pasos y secciones de paso, etc.), puede agregar cualquier código adicional que desee; Nada de eso es particularmente complicado.
Otras secuencias son básicamente las mismas, pero ahí querrás subSequence lugar de substring . (También puede usar subSequence en cadenas, porque una String es una CharSequence .)
Las matrices no son en realidad un tipo de secuencia; Tendrá que escribir el código que crea explícitamente una nueva matriz y copia la sub-matriz. Pero todavía no es mucho más complicado.
Tenga en cuenta que es posible que desee buscar una biblioteca que ya haya hecho esto por usted. Hay al menos tres enlaces en otras respuestas en esta página, lo que debería facilitar su búsqueda. :) (Es posible que aún quieras hacerlo por ti mismo una vez, solo para entender cómo funcionan esas bibliotecas, pero para el código de producción, prefiero usar una biblioteca donde alguien más haya descubierto y probado todos los casos de borde que reimplementar) La rueda y tratar con ellos a medida que quedan atrapados en pruebas de unidad, o errores en el campo ...)
Podría escribir fácilmente dicho método, recuerde que los índices negativos se restan de la longitud de la cadena para obtener el índice correcto.
public String slice(String s, int start) {
if (start < 0) start = s.length() + start;
return s.substring(start);
}
Respuesta simple, no, no la hay. Las cuerdas son inmutables en ambos idiomas. Las cadenas se almacenan internamente como matrices de caracteres, por lo que el uso de subcadenas y los corchetes en Python hacen esencialmente lo mismo. Java no admite la sobrecarga de operadores, por lo que no hay forma de darle esa funcionalidad al lenguaje. Usar subcadenas no es tan malo No deberías tener que hacerlo muy a menudo. Siempre puede escribir funciones de ayuda si lo hace muy a menudo para simplificar su uso.
utilizar substring :
class Main
{
public static void main (String[] args) throws java.lang.Exception
{
String s = new String("hello world");
System.out.println(s.substring(0, s.length()));
System.out.println(s.substring(s.length() - 1, s.length()));
System.out.println(s.substring(3, 4));
}
}
o carácter:
System.out.println(s.charAt(s.length() - 1));
System.out.println(s.charAt(3));
Java no es python, por lo que debe evitarse el índice negativo para mantener la constancia. Sin embargo, podría hacer una función de conversión simple.
Apache commons-lang tiene algo de soporte para esto en StringUtils :
Obtiene una subcadena de la cadena especificada evitando excepciones.
Se puede utilizar una posición de inicio negativa para iniciar n caracteres desde el final de la cadena.
Aún así tendrás que usar un índice de inicio explícito.