# Kako uporabljati Java nize

Java nizi so eden od kompleksnih [podatkovnih tipov v Javi](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/tipi-podatkov-v-javi/). Uporabljajo se za predstavljanje in spreminjanje zaporedja znakov ali številk. Na voljo je več metod, ki vam pomagajo spreminjati nize. V tem vodiču vam predstavljamo osnovne informacije o nizih v Javi.

## Kaj so Java nizi in za kaj se uporabljajo?

Programski jezik Java ima veliko različnih podatkovnih tipov. Najpomembnejši med njimi so [Java primitivni tipi](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-primitivni-tipi/), kot so celo število in znak, ter kompleksni podatkovni tipi, kot so nizi. Niz je **zaporedje znakov ali številk**, ki obstaja kot objekt v razredu java.lang. Nizi se ustvarijo z razredom String in jih nato ni več mogoče spreminjati. Kljub temu se Java nizi še vedno uporabljajo pogosteje kot [StringBuilder](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-stringbuilder/), ki omogoča spreminjanje nizov po njihovi ustvaritvi. Spodaj bomo pojasnili, kako ustvariti niz in katere metode so vam na voljo.

## Kakšna je sintaksa za nize v Javi?

Če želite v Javi ustvariti nov niz, lahko uporabite to preprosto sintakso:

```java
String name = "string";
```

Sistemom signalizirate, da želite ustvariti niz Java, nizu dodelite ime in nato vnesete znake niza **med narekovaje**. Če želite kasneje sklicevati na ta niz, uporabite ime, ki ste mu ga dodelili. Tako izgleda koda za ustvarjanje niza:

```java
public class Main {
	public static void main(String[] args) {
	String example = "Here’s your first Java string.";
	System.out.println(example);
 }
}
```

Izhod je naslednji:

```java
Here’s your first Java string.
```

## Kakšne metode se uporabljajo pri nizih v Javi?

Ker so nizi v Javi objekti, obstaja vrsta metod, ki jih lahko uporabite z njimi. Spodaj bomo predstavili najpomembnejše med njimi.

### `length()`

Metoda `length()` se uporablja za **izpis skupnega števila znakov v nizu**. Kot izpis boste dobili dolžino niza. Tukaj je sintaksa:

```java
stringName.length()
```

Uporaba je prav tako zelo preprosta. Koda je naslednja:

```java
public class Main {
	public static void main(String[] args) {
	String example = "Here’s your first Java string.";
	int length = example.length();
	System.out.println("The string is " + length + " characters long.");
 }
}
```

In dobili boste naslednji izpis:

```java
The string is 30 characters long.
```

### `indexOf()`

Metodo `indexOf()` lahko uporabite za **iskanje enega ali več podnizov znotraj večjega niza**. Tukaj je sintaksa za to:

```java
stringName.indexOf()
```

Za uporabo te metode preprosto vnesite del niza, ki ga želite poiskati.

```java
public class Main {
	public static void main(String[] args) {
	String example = "Here’s your first Java string.";
	System.out.println(example.indexOf("your"));
 }
}
```

Kot izhod boste dobili položaj, na katerem se ta besedilo prvič pojavi:

```java
7
```

### `concat()`

Z `concat()` lahko **povežete dva ločena niza** in oblikujete nov niz. Tukaj je njegova sintaksa:

```java
stringName.concat(string1)
```

Tako metoda deluje v praksi:

```java
public class Main {
	public static void main(String[] args) {
	String example = "word";
	String newString = example.concat("smith");
	System.out.println(newString);
 }
}
```

Tukaj je izhod:

```java
wordsmith
```

### `equals()`

`equals()` je ena od mnogih metod, ki jih lahko uporabite za primerjavo Java nizov med seboj. Metoda vrne **logično vrednost (true ali false)**. Tukaj je njena sintaksa:

```java
string1.equals(string2)
```

V našem primeru bomo ustvarili tri nize in nato prvi primerjali z drugima dvema:

```java
public class Main {
	public static void main(String[] args) {
	String string1 = "ABC";
	String string2 = "ABC";
	String string3 = "DEF";
	System.out.println(string1.equals(string2));
	System.out.println(string1.equals(string3));
 }
}
```

Ker sta prva in druga vrstica identični, tretja pa ne, boste dobili naslednji izpis:

```java
true
false
```

### `toUpperCase()` in `toLowerCase()`

Metodi `toUpperCase()` in `toLowerCase()` služita za pretvorbo vrednosti znakov v nizu v **velike ali male črke**. Tukaj je sintaksa za vsako od njiju:

```java
stringName.toUpperCase()
stringName.toLowerCase()
```

Tako delujejo:

```java
public class Main {
	public static void main(String[] args) {
	String example = "Here’s your first Java string.";
	System.out.println(example.toUpperCase());
	System.out.println(example.toLowerCase());
 }
}
```

Tukaj je izhod:

```java
HERE’S YOUR FIRST JAVA STRING.
here's your first java string.
```

### `split()`

Z metodo [Java split()](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/razdeljevanje-nizov-v-javi/) lahko **razdelite niz Java na manjše podnize**. Tukaj je njena sintaksa:

```java
String[] split(String regex)
```

V praksi to izgleda takole:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Here’s your first Java string";
		String[] output = x.split(" ");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Izhod je videti takole:

```java
Here’s
your
first
Java
string.
```


This is a markdown version of: [https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-nizi/](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-nizi/) for AI/LLM consumption.