Как передать методу массив java

Документация

Когда вы передаете MATLAB ® данные в качестве аргументов на Java ® методы, MATLAB преобразует данные в типы, которые лучше всего представляют данные языку Java. Для получения информации об отображении типа, когда передающие данные к аргументам типа java.lang , смотрите Объекты Передачи Java.

Каждая строка в следующей таблице показывает тип MATLAB, сопровождаемый возможными соответствиями аргумента Java, слева направо в порядке близости соответствия. Типы MATLAB (кроме массивов ячеек) могут быть скалярными массивами (1 на 1) или матрицами. Типы Java могут быть скалярными значениями или массивами.

Тип параметра Java (Скаляр или массив)
Типы кроме объекта

Самый близкий тип наименьшее закрывает тип

string скаляр,
символьный вектор,
char скаляр

string массив,
массив ячеек из символьных векторов
Смотрите аргументы строки передачи.

Объект Java типа jClass

JavaObject из типа jClass

любой суперкласс jClass

массив ячеек объекта

Как размерности массива влияют на преобразование

Термин размерность означает количество индексов, требуемых обратиться к элементам массива. Например, массив 5 на 1 имеет одну размерность, потому что вы индексируете отдельные элементы с помощью одного индекса массивов.

В преобразовании MATLAB к массивам Java MATLAB обрабатывает размерность специальным способом. Для массива MATLAB размерность является количеством неодноэлементных размерностей в массиве. Например, массив 10 на 1 имеет размерность 1. Принимая во внимание, что, массив 1 на 1 имеет размерность 0, потому что вы не можете индексировать в скалярное значение. В коде Java количество вложенных массивов определяет размерность. Например, double[][] имеет размерность 2, и double имеет размерность 0.

Если количество размерностей массива Java совпадает с количеством размерностей в массиве MATLAB n , затем конвертированный массив Java имеет n размерности. Если массив Java имеет меньше, чем n размерности, затем преобразование пропускает одноэлементные размерности, начиная с первой. Преобразование останавливается, когда количество остальных измерений совпадает с количеством размерностей в массиве Java. Если массив Java имеет больше, чем n размерности, то MATLAB добавляет запаздывание одноэлементных размерностей.

Преобразование чисел в целочисленные аргументы

При передаче целочисленного типа методу Java, который берет целочисленный параметр Java, преобразование MATLAB совпадает с преобразованием Java между целочисленными типами. В частности, если целое число из области значений, оно не помещается в количество битов типа параметра. Для целых чисел из области значений MATLAB отбрасывает весь самый низкий n биты. Значение n количество битов в типе параметра. Это преобразование непохоже на преобразование между целочисленными типами MATLAB, где целые числа из области значений преобразованы в максимальное или минимальное значение, представленное целевым типом.

Если аргумент является числом с плавающей запятой, то MATLAB не преобразует его в целое число таким же образом как Java. MATLAB сначала преобразует число с плавающей запятой в 64-битное целое число со знаком с усеченной дробной частью. Затем номер обрабатывается, как будто это был int64 аргумент.

Число с плавающей запятой является слишком большим, чтобы быть представленным в 64-битном целом числе, когда это (вне диапазона от-2 63 –2 63 . В этом случае MATLAB использует следующие преобразования:

• int , short , и byte значения параметров к 0 .
• long значения параметров к java.lang.Long.MIN_VALUE .
• Inf и -Inf значения к -1 .
• NaN значения к 0 .

Передача аргументов строки

Вызывать метод Java с аргументом, заданным как java.lang.String , передайте строку MATLAB или вектор символов. MATLAB преобразует аргумент в Java String объект. Также можно передать String объект возвращен методом Java.

Если аргумент метода является массивом типа String , затем передайте массив строк или массив ячеек из символьных векторов. MATLAB преобразует вход в массив Java String объекты, с размерностями, настроенными как описано в Как размерностях массива влияют на преобразование.

Передача объектов Java

Вызывать метод, который имеет аргумент, принадлежащий классу Java (кроме java.lang.Object ), необходимо передать объект Java, который является экземпляром того класса. MATLAB не поддерживает автоупаковку Java, автоматическое преобразование типов MATLAB на Java Object типы. Например, MATLAB не преобразует double к java.lang.Double для параметра типа Double .

Передайте java.lang.Object

Особый случай существует, когда метод берет аргумент java.lang.Object класс. Поскольку этот класс является корнем иерархии класса Java, можно передать объекты любого класса в аргументе. MATLAB автоматически преобразует аргумент в самый близкий Java Object введите, который может включать автоупаковку стиля Java. Эта таблица показывает преобразование.

JavaObject в пакете java.lang

Передача массива в метод с переменными аргументами в Java

Часто разработчики сталкиваются с задачей передать массив в качестве аргументов методу с переменными аргументами в Java. При этом возникает проблема:

Алексей Кодов
Автор статьи
10 июля 2023 в 15:45

Часто разработчики сталкиваются с задачей передать массив в качестве аргументов методу с переменными аргументами в Java. При этом возникает проблема: массив воспринимается как один объект, а не как набор отдельных элементов.

Приведем пример. Предположим, есть следующий метод:

public void printAll(Object. args) < for (Object arg : args) < System.out.println(arg); >>

И массив объектов, который нужно передать этому методу:

Object[] myArray = new Object[];

Если передать этот массив методу printAll(), то он будет воспринят как один объект, а не как три разных элемента.

printAll(myArray);

На экран выведется информация об одном объекте, а не о трех разных.

Решение проблемы

В Java для решения этой проблемы предусмотрена специальная конструкция. Если перед массивом поставить троеточие, то он будет распакован, и каждый его элемент будет передан в метод как отдельный аргумент.

printAll(myArray. );

Теперь метод printAll() получит три разных аргумента, и на экран будут выведены все три элемента массива.

Но что делать, если в метод нужно передать не только массив, но и другие аргументы? В этом случае можно использовать такую конструкцию:

printAll("Extra argument", myArray. );

«Extra argument» будет передан в метод как первый аргумент, а затем будут переданы все элементы массива.

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

Как передать методу массив java

В первой части руководства мы подробно рассмотрели одномерные массивы и операции, применимые к ним. В данной же статье разбирается такая тема, как varargs.

1. Varargs

Varargs (Variable Arguments List, изменяющийся список аргументов) — это способ создания методов, которые могут принимать произвольное количество аргументов одного типа (от нуля и более). Данная возможность появилась в JDK 5.

В книге «Java. Эффективное программирование» Джошуа Блох пишет: «Использование переменного количества аргументов было разработано для метода printf и рефлексии». Также он называет varargs-методы, как variable arity, т. е. методы с переменной арностью (термин из математики, означающий количество передаваемых аргументов).

Давайте на примере printf и разберем данную функцию языка.

Метод printf (аналог одноименного метода из языка C), как и методы print и println, предназначен для вывода сообщений в консоль, но, в отличие от последних, позволяет применять к ним форматирование. Реализации данных методов находятся в пакете java.io в классе PrintStream, но их мы знаем как методы, вызываемые в конструкции System.out.*

Приведем пример реализации printf:

 public PrintStream printf(String format, Object. args)

Данный метод принимает следующие аргументы:

• String format — выводимое на консоль сообщение, включающее параметры форматирования (дескрипторы)
• Object… args — произвольное количество значений форматируемых переменных

В целом, можно сказать, что инструкции из String format применяются для форматирования аргументов Object… args.

Запись вида Object… args и есть varargs. Существуют, конечно, и другие способы написания: Object …args или даже Object … args, но они не распространены, и их использовать не стоит. При этом три точки после типа указывают, что метод в качестве аргумента может принимать как массив, так и любую последовательность аргументов, записанных через запятую, которая все равно преобразуется в одномерный массив.

Пусть имеется следующий метод:

 public void foo(int. args) <> 

Мы его вызываем так:

 foo(10, 20); 

«Под капотом» компилятор на уровне байт-кода неявно заменяет переданную последовательность массивом. По смыслу это равносильно следующей записи:

 foo(new int[]); 

Varargs работает следующим образом: без участия программиста создается массив, размер которого определяется числом передаваемых аргументов, инициализируется ими, а затем передается в метод. Уже в методе аргумент varargs используется как одномерный массив.

Вернемся к методу printf и приведем пример его применения:

 System.out.printf("Hello"); System.out.printf("Player %s attempts: ", player.getName()); System.out.printf("%5s %5s %n", "Dec", "Char"); System.out.printf("Число %,d содержит %d %s количество единиц%n", a, b, c); 

Как видно из примера, printf может принимать разное количество аргументов: в нашем случае от одного до четырех. Такая гибкость как раз и обеспечивается за счет конструкции Object… args (тип ожидаемых аргументов может быть любым, не обязательно Object).

Реализовать такую универсальность до введения varargs было возможно двумя способами:

1. Использовать массив в качестве контейнера для передачи в метод разного количества аргументов (зачастую это громоздко):

 char[] arr = new char[4]; arr[0] = 'J'; arr[1] = 'a'; arr[2] = 'v'; arr[3] = 'a'; print(arr); void print(char[] arr) < // какой-то код >

можно, конечно, чуть короче:

 char[] arr = ; print(arr); 

Или даже так:

 print(new char[]); 

Но это не всегда бывает возможно.

2. Реализовать множество перегруженных методов, принимающих различное число аргументов (что не самая плохая идея, в пределах разумного, в чем мы убедимся далее). Но это сильно засоряет класс, приводя программистов в недоумение от большого числа почти одинаковых методов, да и не всегда понятно, какое количество перегруженных методов нужно реализовать и когда стоит остановиться

В качестве примера можно привести метод для передачи игроков в какую-то игру:

 void start(Player p1) <> void start(Player p1, Player p2) <> void start(Player p1, Player p2, Player p3) <> void start(Player p1, Player p2, Player p3, Player p4) <> 

Как альтернатива подобной многословности как раз и был предложен varargs.

Разработчики Java посчитали, что нужно предоставить возможность создавать методы с заранее неизвестным числом аргументов без использования массивов, делегировав эту задачу компилятору. Подобные упрощения в языках программирования обычно называются синтаксическим сахаром.

Целью создания таких фич, как varargs, является:

• упрощение кода
• уменьшение многословности языка
• облегчение работы программиста
• удобство

Разберем еще один пример.

Пусть необходимо реализовать метод, который принимает последовательность аргументов типа String и отображает их в консоли. Для демонстрации воспользуемся методом main, используя в качестве принимаемого аргумента varargs. При этом следует отметить, что String[] и String… являются синонимами.

 public class VarargsTest < public static void main(String. args) < System.out.println("Длина массива (количество аргументов) = " + args.length); for (String str : args) < System.out.print(str + " "); >> > 

Запустим в консоли программу, введя любой текст после названия класса:

 > java VarargsTest.java My name is Max! Длина массива (количество аргументов) = 4 My name is Max! 

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

В качестве ограничения любой метод может использовать varargs только в единственном числе и строго последним аргументом.

Приведем примеры неправильного использования varargs:

 1. public void foo1(int. nums, String values) <> 2. public void foo2(String. values, int. nums) <> 3. public void foo3(String[] values, . int nums) <> 

Ни один из вариантов не скомпилируется потому, что:

1. varargs не является последним
2. два varargs не допускаются в одном методе
3. … необходимо размещать после типа, а не до него

И еще один пример:

 public int howMany(boolean b, boolean. b2)

Варианты вызова метода:

 A. howMany(); B. howMany(true); C. howMany(true, true); D. howMany(true, true, true); E. howMany(true, ); F. howMany(true, new boolean[2]); 

• Вариант A не cкомпилируется, потому что в методе не передается хотя бы начальный параметр (boolean b). Тут действует то правило, когда varargs может быть равен 0, но все остальные аргументы обязательно должны быть переданы
• Вариант B и C правильные, т. к. первый вызов соответствует правилу из предыдущего пункта, а во втором создается массив размером 1
• Варианты D и F правильные, т. к. передают нужное количество аргументов: начальный и еще два для преобразования в массив varargs размером 2
• Вариант E не скомпилируется, потому что неверно объявляется массив: должно быть new boolean[]
• Вариант F верный, т. к. передает начальный параметр и массив размером 2 (массивы и varargs являются синонимами)

 of() of(E e1) of(E e1, E e2) of(E e1, E e2, E e3) of(E e1, E e2, E e3, E e4) of(E e1, E e2, E e3, E e4, E e5) of(E e1, E e2, E e3, E e4, E e5, E e6) of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) of(E. elements) 

static void test(int. array)

static void test(double d, int. array)

public class VarArgs < static void test(int. array) < System.out.println("Количество аргументов: " + array.length); for (int a : array) < System.out.print(a + " "); >System.out.println(); > public static void main(String[] args) < test(); test(1); test(1, 2); test(new int[]); > >

public class VarArgs2 < static void test(double. array) < System.out.println("test(double. array)"); System.out.println("Количество аргументов: " + array.length); for (double a : array) < System.out.print(a + " "); >System.out.println(); > static void test(int. array) < System.out.println("test(int. array)"); System.out.println("Количество аргументов: " + array.length); for (int a : array) < System.out.print(a + " "); >System.out.println(); > static void test(int a) < System.out.println("test(int a)"); >public static void main(String[] args) < test(); test(3); test(1.0); test(1, 2); >>

test(int. array) Количество аргументов: 0 test(int a) test(double. array) Количество аргументов: 1 1.0 test(int. array) Количество аргументов: 2 1 2 

public class VarArgs3 < static void test(boolean. array) < System.out.println("test(boolean. array)"); System.out.println("Количество аргументов: " + array.length); for (boolean a : array) < System.out.print(a + " "); >System.out.println(); > static void test(int. array) < System.out.println("test(int. array)"); System.out.println("Количество аргументов: " + array.length); for (int a : array) < System.out.print(a + " "); >System.out.println(); > public static void main(String[] args) < // test();// ошибка неоднозначности test(3); test(1, 2); >>