From 8007485316c80b3d29244c285a2c84ae205fbcfa Mon Sep 17 00:00:00 2001 From: StNicolay Date: Sun, 24 Sep 2023 09:01:39 +0000 Subject: [PATCH] C# 24.09.2023 --- C#/C#.md | 242 +++++++++++++++++++++++++++++++++++++++++++++++++++ Java/Java.md | 76 ++++++++++++++++ 2 files changed, 318 insertions(+) create mode 100644 Java/Java.md diff --git a/C#/C#.md b/C#/C#.md index a3c78ec..4c7b94a 100644 --- a/C#/C#.md +++ b/C#/C#.md @@ -108,3 +108,245 @@ int foo = Convert.ToInt32(Console.ReadLine()); * \* * / * % + +## Преобразование базовых типов данных + +Операция сложения и вычитания возвращает int, если типы, на которые применяется операция, <= int (byte, short, int) + +### Неявное преобразование + +Работает только на расширение + +```C# +byte a = 4; +ushort = a; +``` + +### Явное преобразовывание + +Работает на расширение и на сужение + +```C# +byte a = 5; +byte b = 4; +byte c = (byte) (a+b); +``` + +## Ветвление + +```C# +int a = 5; + +if (a == 5) { + Console.WriteLine("It works"); +} else { + Console.WriteLine("Cosmic ray!"); +} +``` + +### Тернарный оператор + +Краткая возвращающая форма if + +```C# +int x = 3; +int y = 5; + +string z = x < y ? "Works" : "Cosmic ray"; +``` + +### Switch + +```C# +int number = 1; + +switch (number) { + case 1: + Console.WriteLine("case 1"); + goto case 5; + case 3: + Console.WriteLine("case 3"); + break; + case 5: + Console.WriteLine("case 5"); + break; + default: + Console.WriteLine("case whatever"); + break; +} +``` + +### Циклы + +Всё как в С++ + +* while +* do-while +* for +* foreach + +## Массивы + +Массивы позволяют хранить заранее известное кол-во элементов вместе + +### Инициализация массивов + +```C# +int[] a = new int[3] {10, 20, 30}; +double[] b = new double[5]; +float[] c = {1.5f, 2.3f}; // Поймёт, что нужна длина 2 +``` + +### Длинна массивов + +```C# +int[] a = {10, 20}; +int len = a.Length; +``` + +### Методы + +```C# +int[] a = {10, 30, 20}; + +Array.IndexOf(a, 10) // Вернёт 0. -1, если не найдёт. +Array.Sort(a); // Сортирует по возрастанию. Станет {10, 20, 30} +``` + +### Двумерный массив + +```C# +int[,] a = new int[10,10]; +``` + +### Динамический массив + +```C# +using System.Collections.Generic; + +List words = new List (); +words.Add("Foo"); +words.Add("Bar"); +words.RemoveAt(1); +``` + +## Random + +```C# +Random r = new Random(); +int a = r.Next(); // От 0 до 2 миллиардов +int b = r.Next(5); // От 0 до 5 (не включительно) +int c = r.Next(3, 5); // От 3 до 5 +``` + +## Функции + +```C# +void Foo() { + Console.WriteLine("Hello"); +} + +// Краткая форма +void Bar() => Console.WriteLine("Hi"); +``` + +### Параметры функции + +```C# +int Sum(int x, int y) => x + y; // Тут x и y - параметры + +Sum(5, 6); // Тут 5 и 6 - аргументы +``` + +#### Необязательные параметры + +```C# +void PrintPerson(string name, int age = 1) { + Console.WriteLine($"{name} - {age}"); +} + +PrintPerson("John", 5); +PrintPerson(age: 5, name: "Bob"); // Именованные параметры +``` + +#### Передача по ссылке + +При передаче по ссылке и зменения внутри функции меняют оригинальное значение + +```C# +void Inc(ref int a) { + a++; +} + +void BadInc(int a) { + a++; +} + +int b = 5; +Inc(ref b); // b == 6 +BadInc(b); // b осталась 6 + +Inc(b); // Так низя +Inc(5); // И так низя +Inc(ref 5); // И так тоже низя +``` + +#### Выходной параметр + +Функция может иметь несколько выходных параметров, а так лучше return + +```C# +void Sum(int a, int b, out int result) { + result = a + b; +} + +int result; + +Sum(5, 6, out result); +``` + +#### Входные параментры + +Передача по неизменяемой ссылке. Судя по всему полезно только для массивов + +```C# +int Sum(in int a, in int b) { + return a + b; +} + +int a = 5; +int b = 6; +Sum(a, b); +``` + +#### params + +*params* позволяет передать не определённое кол-во параметров. После него не может быть больше параметров + +```C# +int Sum(params int[] nums) { + int sum = 0; + + foreach (int i in nums) { + sum += i; + } + + return sum; +} + +int[] nums = {1, 2, 3, 4}; +Sum(nums); +Sum(1, 2, 3); +Sum(20); +Sum(); +``` + +### Возвращение значений + +```C# +int Sum1(int a, int b) { + return a + b; +} + +int Sum2(int a, int b) => a + b; +``` diff --git a/Java/Java.md b/Java/Java.md new file mode 100644 index 0000000..a8b5e2c --- /dev/null +++ b/Java/Java.md @@ -0,0 +1,76 @@ +# Java + +## Функция main + +```Java +package org.example; + +public class Main { + public static void main(String[] args) { + System.out.println("Hello world!"); + } +} +``` + +## Сокращения InteliJ + +* psvm - public static void main +* sout - Sytem.out.println() +* serr - System.err.println() +* I - for(Object object: ){} +* fori - for (int i = 0; i< ; i++) {} +* shift + shift - поиск по проекту +* ctrl + alt + t - сниппеты для блоков кода (циклы, if, switch, try-catch) +* alt + insert - сниппеты для класса + +## Строки + +Строки неизменяемые (immutable) и не могут иметь наследников (final). Для изменения копии + +```Java +// foo и bar - 1 объект в Pool (аля static) +String foo = "foo"; +String bar = "foo"; +// baz - объект в куче +String baz = new String("baz"); +``` + +### StringBuffer и StringBuilder + +Данные типы - изменяемые строки с изменениями на месте. StringBuffer синхронизирует методы, поэтому медленее, но можно работать в многопотоке. StringBuilder быстрее, но методы не синхронизирует + +```Java +// Можно передать строку в инициализатор, но не обязательно +StringBuffer sb = new StringBuffer(); + +sb.append("foo"); +sb.append(5); +``` + +#### Методы StringBuffer и StringBuilder + +* append (смотреть выше) +* delete(int start, int end) +* insert(int offeset, String str) +* replace(int start, int end, String str) +* reverse() +* substring(int start, int end) - создаст новую строку +* toString - перевести в строку + +### RegEx + +RegEx - щаблон для поиска строки в тексте + +#### Примеры RegEx + +* "java" - только слово java подойдёт +* "\\d{3}" - 3 цифры + +#### Pattern для RegEx + +Pattern - скомпилированный RegEx + +```Java +Pattern p = Pattern.compile("java"); +p = Pattern.compile("java", Pattern.CASE_INSENSETIVE); +```