1, 10, 5
	1, 10, 70

static boolean compareArrays (int [] ar1, int [] ar2) {
//сравним длины
	if (ar1.length != ar2.length )
		//return завершает функцию на данном моменте
		//мы вернули false, т.к. массивы не равны:
		return false; 
// если программа дошла до сюда, значит if не сработал, ведь в нем был return
//теперь совершим обход массивов в поисках не равных элементов:
//обычная шапка – идем по обоим массивам вместе:
	for (int i = 0; i < ar1.length; i ++)
		if (ar1 [i] != ar2 [i]) //если нашли два неравных, то вернуть false
			return false;
/*раз ни один из if внутри цикла не сработал и программа до сюда дошла, то 
ВСЕ элементы на iых местах в ar1 и ar2 были равны. Смело возвращаем true:*/
	return true;
}
//Теперь в main мы можем протестировать эту функцию:
public static void main () {
	int [] ar1 = {1, 4, 6};
	int [] ar2 = {1, 4, 6};
	int [] ar3 = {1, 9, 9};
	System.out.println (compareArrays (ar1, ar2));//true-равны
	System.out.println (compareArrays (ar2, ar3));//false-неравны
}

	for (int i = 0; i < ar1.length; i ++)
		if (ar1 [i] != ar2 [i]) //если нашли два неравных, то вернуть false
			return false;
		else return true;  /* ОШИБКА – мы сравним не весь массив, а лишь начальные элементы */

static boolean compareArrays (int [] ar1, int [] ar2) {
//сравним длины
	if (ar1.length != ar2.length )
		return false; 
	boolean result = true;
	for (int i = 0; i < ar1.length; i ++)
		if (ar1 [i] != ar2 [i]) {
			result = false;
			break; //break останавливает цикл
		}
	return result; 
}

static int[] concatArrays (int [] ar1, int [] ar2) {
//выделим память под новый большой массив-склейку.
	int [] ar3 = new int [ar1.length + ar2.length];
//скопируем в начало первый массив в начало второго:
	for (int i = 0; i < ar1.length; i ++)
		ar3 [i] = ar1 [i];
//скопируем второй массив сразу после первого:
	for (int i = 0; i < ar2.length; i ++)
		ar3 [ar1.length + i] = ar2 [i]; //следите за тем, чтобы дать нужный номер элемента в квадратных скобках. ar3 приравнивается к ar2
	
	return ar3;
}
//в main сможем использовать так:
public static void main () {
	int [] some1 = {1, 2, 3};
	int [] some2 = {4, 5, 6};
// вызовем функцию и возвращаемый массив запишем в some3
	int [] some3 = concatArrays (some1, some2);
	printArray (some3); // будет 1 2 3 4 5 6 – два массива склеены в новом
}

static int[] concatArrays (int [] ar1, int [] ar2) {
//выделим память под новый большой массив-склейку.
	int [] ar3 = new int [ar1.length + ar2.length];
//скопируем в начало первый массив в начало второго:
	for (int i = 0; i < ar1.length; i ++)
		ar3 [i] = ar1 [i];
//скопируем второй массив сразу после первого:
	for (int i = 0; i < ar2.length; i ++)
		ar3 [ar1.length + i] = ar2 [i]; //следите за тем, чтобы дать нужный номер элемента в квадратных скобках. ar3 приравнивается к ar2
	
	return ar3;
}
//в main сможем использовать так:
public static void main () {
	int [] some1 = {1, 2, 3};
	int [] some2 = {4, 5, 6};
// вызовем функцию и возвращаемый массив запишем в some3
	int [] some3 = concatArrays (some1, some2);
	printArray (some3); // будет 1 2 3 4 5 6 – два массива склеены в новом
}

static int searchMin (int [] ar) {
	int curMin = ar [0];//быть может нулевой – минимальный?
	for (int i = 0; i < ar.length; i ++)
		if (ar[i] < curMin) //если есть меньше минимального
			curMin = ar [i]; // то мы возьмем новый минимальный
//если мы бы хотели узнать, ГДЕ был минимум, то сохранили бы i
	return curMin; 
}

static int countSym (char [] str, char sym) {
	int count = 0;
	for (int i = 0; i < str.length; i ++)
		if (str [i] == sym)
			count ++;//если нашли символ, то увеличили count

	return count;
}

	int tmp = ar [i]; //сохранили i-ый элемент в tmp
	ar [i] = ar [j]; //мы забыли элемент ar[i], записав в него j-ый
	ar[j] = tmp; //записали сохраненное в tmp значение в j-ую ячейку
//подумайте над этим простым алгоритмом. Его нужно хорошо понимать.

static void inverseArray (int [] ar) {
	int tmp = 0;

	for (int i = 0; i < ar.length/2; i ++) {
//меняем местами элементы под номерам:
//с одной стороны “i”, с другой “ar.length-1-i”
//то есть меняем элементы местами с начала и конца
		tmp = ar [i];
		ar [i] = ar [ar.length – 1 – i];
		ar [ar.length-1-i] = tmp;
	}
}
//заметьте, что условие i < ar.length/2 дает нам развернуть массив один раз
// если мы оставим старое i < ar.length, то развернем массив дважды
// и он в итоге останется точно тем же, что и был в начале
//Для запуска этой функции в main сделаем такой код:
public static void main () {
	int [] ar1 = {9, 8, 7, 6, 5, 4, 3, 2, 1};
	inverseArray (ar1);
	printArray (ar1);
}

void increase (int x) 
{
	 x = x +1; //казалось бы икс увеличился на 1
}
public static void main () {
	int y = 0;
	increase (y);
	System.out.println (y);
//как игрек был нулем, так нулем и остался – печально..
}

int [] ar1 = {1, 2, 3};
int [] ar2 = ar1; //присвоена только ссылка, так что реально это тот же массив
ar2 [0] = 10; //изменились оба массива! Не только ar2.
Systtem.out.println (ar1[0]); //распечатается 10, хоть мы и изменили ar2
	С переменными примитивных типов другая история – при присваивании копируется значение. Это не ссылки, а просто значения. К этому мы уже и привыкли:
int x = 1;
int y = x;
y = 10;
System.out.println (x); //по-прежнему 10, ведь y с иксом – разные переменные

package javaapplication1;
public class JavaApplication1 {
public static void main(String[] args) {
  int x = 100;
  x = x*10/2 + x;
  System.out.println (x);

  double y = x - 5.5;

  System.out.println (y);
 }   
}